TP : modèle de référence d’une ALU sur huit bits

Rendre le contrat numérique exécutable

Ce TP modélise une ALU combinatoire avec des entiers JavaScript. Les opérandes vont de 0 à 255 et les opérations de 0 à 3. La sortie y tient toujours sur huit bits. Le drapeau représente la retenue ADD ou l’emprunt SUB, et vaut zéro pour les opérations logiques. Dans cette interface, l’emprunt vaut un lorsque a est inférieur à b. D’autres architectures peuvent définir les drapeaux de soustraction différemment ; notre contrat est explicite.

Créez un dossier local, ou créez manuellement un projet vide et ajoutez alu-model.mjs dans Digital Design Studio. Enregistrez le fichier suivant. Dans un terminal où Node.js est installé, entrez dans ce dossier et exécutez node alu-model.mjs. La modification d’un fichier dans DDS et l’exécution de JavaScript sont deux actions distinctes. Aucune installation de paquet ni fonctionnalité d’importation automatique n’est nécessaire.

import assert from 'node:assert/strict';
function alu(a, b, op) {
  if (op === 0) {
    const wide = a + b;
    return { y: wide & 255, flag: Number(wide > 255) };
  }
  if (op === 1) return { y: (a - b) & 255, flag: Number(a < b) };
  if (op === 2) return { y: a & b, flag: 0 };
  if (op === 3) return { y: a ^ b, flag: 0 };
  throw new RangeError('operation');
}
assert.deepEqual(alu(250, 10, 0), { y: 4, flag: 1 });
assert.deepEqual(alu(3, 5, 1), { y: 254, flag: 1 });
assert.deepEqual(alu(170, 204, 2), { y: 136, flag: 0 });
assert.deepEqual(alu(170, 204, 3), { y: 102, flag: 0 });
let checks = 0;
for (let a = 0; a < 256; a++) {
  for (let b = 0; b < 256; b++) {
    const add = alu(a, b, 0), sub = alu(a, b, 1);
    assert.equal(add.y + 256 * add.flag, a + b);
    assert.equal(sub.y - 256 * sub.flag, a - b);
    assert.equal(alu(a, b, 2).y | alu(a, b, 3).y, a | b);
    checks += 3;
  }
}
console.log(`ALU PASS: ${checks} identities`);

Pour 250+10, y=4 et carry=1 permettent de reconstruire 260. Pour 3-5, y=254 et borrow=1 permettent de reconstruire -2. En binaire, 170 vaut 10101010 et 204 vaut 11001100 : AND donne 136 et XOR donne 102. La boucle parcourt les 65536 paires d’opérandes et vérifie trois identités par paire. Une exécution réussie annonce 196608 vérifications.

Utilisez dans le modèle de référence une méthode différente de celle du RTL. Si le matériel extrait la retenue d’un additionneur sur neuf bits, ce modèle vérifie la plage mathématique. Cela réduit le risque d’erreurs communes aux deux implémentations. Ces vérifications n’évaluent ni les valeurs HDL X/Z, ni les délais de propagation, ni le comportement d’horloge. Réutilisez les vecteurs dans un simulateur lors de l’implémentation RTL. Comparez toujours les drapeaux et les données : des bits modulaires corrects peuvent masquer un drapeau de limite incorrect.