Architecture

Logisim

Logisim est un logiciel de simulation écrit en Java,qui nous permettra de simuler et tester certaines portes logiques

Lancer Logisim à partir du répertoire isn

Portes logiques élémentaires

Il s'agit d'implémenter les portes Not,And,Or et Xor uniquement avec des portes Nand

Même si ces portes sont déjà à disposition dans logisim , nous allons utiliser la logique des sous-circuits (identique à celle des fonctions) pour créer un sous-circuit pour chacune de ces portes

  1. Not

    Not(x) = Nand(x,x)

    Selectionner Add Circuit... dans le menu Project et entrer le nom du circuit Nand2Not

    Construire le circuit et tester le avec Poke

    Cliquer sur A pour pouvoir insérer du texte sur le circuit

    Ensuite cliquer sur le pin d'entrée et étiqueter in

    Faire de même avec le pin de sortie et étiqueter out

  2. And

    And(x,y) = Not(Nand(x,y))

    Selectionner Add Circuit... dans le menu Project et entrer le nom du circuit Nand2And

    Par glisser-déposer prendre 2 pins d'entrée, un sous-circuit Nand2Not et une porte Nand

    Pour cabler Nand2Not on fait glisser la souris au-dessus de la porte pour faire apparaître les étiquettes d'entrée in et de sortie out

    Etiqueter les deux entrées in1 et in2 et la sortie out

    Construire le circuit

  3. Or

    Sachant que Not(Or(x,y)) = And(Not(x),Not(y)), exprimer Or(x,y) uniquement à partir des portes Nand et Not

    Créer un nouveau sous-circuit Nand2Or

  4. Xor(ou exclusif)

    Sachant que Xor(x,y) = Or(And(Not(x),y),And(x,Not(y))), créer un nouveau sous-circuit Nand2Xor

Portes logiques composites

Arithmétique

  1. Additionneur 1 bit

    Un additionneur 1 bit est vu comme deux fonctions booléennes s le chiffre des unités et cout la retenue de sortie dépendant de trois entrées

    3 entrées : deux bits a et b et une retenue d'entrée cin

    2 sorties : Le bit de résultat s et une retenue de sortie cout

    Après avoir fait la table de vérité des fonctions s et cout, on obtient comme circuit

    Créer un circuit add1 qui implémente l'additionneur 1 bit à partir du schéma ci-dessous

  2. Additionneur 4 bits

    En utilisant 4 additionneurs 1 bit créer un additionneur 4 bits

Le temps

Une horloge (clock) délivre un signal périodique par exemple 1 ns (pour une fréquence de 1GHz) . Pour les composants liés à l'horloge (clocked) chaque période compte comme une unité de temps

Lancer Logisim

Réaliser le circuit ci-dessous avec:

et constater le décalage de la sortie (out) sur l'entrée (in)

Les registres

Nous allons construire un circuit contenant une entrée in(t) (1 bit), un sélecteur load (1 bit) et une sortie out(t) (1 bit) dont le contrat est :

Si load == 1 alors out(t) = in(t-1) sinon out(t) = out(t-1)

C'est le circuit ci-dessous, on utilise un multiplexer pour réaliser le si ...alors

Tester le avec Poke

Ensuite tester le registre à 8 bits fourni par Logisim

Mémoire RAM

Réaliser le circuit suivant simulant une mémoire de 256 octets (vérifier le) .Tester le

Program Counter

Un program counter est un élément du processeur qui à chaque unité de temps t, délivre l'adresse mémoire de la prochaine instruction du programme à exécuter. Il a 4 entrées in, inc, load ,reset, et une sortie.

Assembler le code machine

Ecrire le programme suivant en Python


import dis
dis.dis('x = 2;x = x + 3')

Un programme Python est traduit en langage machine pour être exécuté

Chaque instruction contient un code que le processeur peut décoder ce qui permet ensuite au processeur d'exécuter une tâche bien précise

Avant de voir les codes machines correspondants aux deux instructions précédentes nous allons voir les codes sous forme compréhensible (le langage assembleur)

Pour deux instructions (deux affectations) en assembleur il y a 7 actions

Chaque action par exemple LOAD_CONSTANT a un sens bien précis défini dans la documentation Python

Un élément important, la pile (stack) permet de simplifier la gestion des opérations

Voici comment est effectué l'addition

A partir de ces éléments on peut décoder le code assembleur:

Chaque action a 2 octets, un octet pour le code opératoire (opcode) par exemple LOAD_CONST, puis un octet pour l'adresse mémoire (ou pas)

Si on veut désassembler le code assembleur LOAD_CONST et obtenir le code machine correspondant on utilise le dictionnaire opmap ainsi

Ainsi LOAD_CONST 0 est traduit par 0x64 0x00

Exercice

Finir la traduction

Que donnera en langage assembleur et en langage machine les instructions suivantes ?


x = 2
y = 3
z = x + y