Laboratorio: modello di riferimento di un'ALU a otto bit

Rendi eseguibile il contratto numerico

Questo laboratorio modella un'ALU combinatoria usando interi JavaScript. Gli operandi vanno da 0 a 255, con operazioni da 0 a 3. L'uscita y rientra sempre in otto bit. Il flag indica il riporto ADD o il prestito SUB ed è zero per le operazioni logiche. In questa interfaccia, il prestito vale uno quando a è minore di b. Altre architetture possono definire diversamente i flag di sottrazione; il nostro contratto è esplicito.

Crea una cartella locale, oppure crea manualmente un progetto vuoto e aggiungi alu-model.mjs in Digital Design Studio. Salva il file seguente. In un terminale con Node.js installato, entra nella cartella ed esegui node alu-model.mjs. Modificare un file in DDS ed eseguire JavaScript sono azioni distinte. Non occorrono installazioni di pacchetti o funzionalità di importazione automatica.

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`);

Per 250+10, y=4 e carry=1 ricostruiscono 260. Per 3-5, y=254 e borrow=1 ricostruiscono -2. In binario, 170 è 10101010 e 204 è 11001100: AND dà 136 e XOR dà 102. Il ciclo visita tutte le 65536 coppie di operandi e verifica tre identità per coppia. Un'esecuzione riuscita riporta 196608 verifiche.

Usa nel modello di riferimento un metodo diverso da quello dell'RTL. Se l'hardware estrae il riporto da un sommatore a nove bit, questo modello verifica l'intervallo matematico. Ciò riduce gli errori di implementazione condivisi. Queste verifiche non valutano i valori HDL X/Z, i tempi di propagazione o il comportamento del clock. Riutilizza i vettori in un simulatore quando implementi l'RTL. Confronta sempre i flag oltre ai dati; bit modulari corretti possono nascondere un flag di limite errato.