diff --git a/404.html b/404.html index bfc968a..81b1ca5 100644 --- a/404.html +++ b/404.html @@ -4,13 +4,13 @@ Page Not Found | Computer Architecture - +
Skip to main content

Page Not Found

We could not find what you were looking for.

Please contact the owner of the site that linked you to the original URL and let them know their link is broken.

- + \ No newline at end of file diff --git a/Curs/index.html b/Curs/index.html index 7e58946..3124055 100644 --- a/Curs/index.html +++ b/Curs/index.html @@ -4,13 +4,13 @@ Curs | Computer Architecture - +
Skip to main content

Curs

- + \ No newline at end of file diff --git a/Curs/intro/index.html b/Curs/intro/index.html index cbe6b1d..b8bc81e 100644 --- a/Curs/intro/index.html +++ b/Curs/intro/index.html @@ -4,13 +4,13 @@ intro | Computer Architecture - +
Skip to main content

intro


tip

Focus the slides and press F for fullscreen viewing.

- + \ No newline at end of file diff --git a/Evaluare/Teme/FPU/index.html b/Evaluare/Teme/FPU/index.html index b85349d..6db19d5 100644 --- a/Evaluare/Teme/FPU/index.html +++ b/Evaluare/Teme/FPU/index.html @@ -4,13 +4,13 @@ FPU | Computer Architecture - +
Skip to main content

FPU

Implmentați modulul verilog pentru un FPU (floating point unit) cu 2 operanzi 32-bits IEEE754.

Intrările sunt:

  • i_w_op1 - primul operand (32 de biți)
  • i_w_op2 - al doilea operand (32 biți)
  • i_w_opsel - linie de selecție a operației (3 biți)

Ieșirea este:

  • o_w_out - rezultatul operației între cei doi operanzi (32 biți)

Operațiile sunt:

Operation Code (i_w_opsel)OperationResult
000Additionop1 + op2
001Subtractionop1 - op2
010Multiplicationop1 * op2
011Divisionop1 / op2
100Negation-op1
101Absolute Value|op1|
110Less thanop1 < op2
111Equalop1 == op2

Standardul IEEE754 poate fi găsit la următorul link.

Pentru a vă ajuta în rezolvare avem următoarele materiale video:

- + \ No newline at end of file diff --git a/Evaluare/Teme/index.html b/Evaluare/Teme/index.html index 64d9852..eeb1c24 100644 --- a/Evaluare/Teme/index.html +++ b/Evaluare/Teme/index.html @@ -4,13 +4,13 @@ Teme | Computer Architecture - +
Skip to main content

Teme

- + \ No newline at end of file diff --git "a/Evaluare/Test Circuite Combina\310\233ionale/7 LED Segment/index.html" "b/Evaluare/Test Circuite Combina\310\233ionale/7 LED Segment/index.html" index 5093b41..9b0885b 100644 --- "a/Evaluare/Test Circuite Combina\310\233ionale/7 LED Segment/index.html" +++ "b/Evaluare/Test Circuite Combina\310\233ionale/7 LED Segment/index.html" @@ -4,13 +4,13 @@ 7-LED Segment DIGIT | Computer Architecture - +
Skip to main content

7-LED Segment DIGIT

Implementați un modul verilog care să afișeze in funcție i_w_digit o cifră specifică.

Intrările modulului sunt:

  • i_w_digit - ce cifră se va afișa (2 biți)

Ieșirele modulului sunt:

  • o_w_ca - linia ca din 7-led segment
  • o_w_cb - linia cb din 7-led segment
  • o_w_cc - linia cc din 7-led segment
  • o_w_cd - linia cd din 7-led segment
  • o_w_ce - linia ce din 7-led segment
  • o_w_cf - linia cf din 7-led segment
  • o_w_cg - linia cg din 7-led segment

Pentru a afla cifrele ce trebuie afișate în funcție de i_w_digit apăsați butonul "evaluate" din VPL.

Avem un 7-led segment cu anod comun și ieșirele vor fi active când vor avea valoarea 1'b0.

Mai jos puteți vedea cum sunt poziționate linile cx ale 7-led segment.

7-LED-SEGMENT

Mai jos puteți vedea cum sunt afișate cifrele zecimale pe un 7-led segment.

7-LED-DIGITS

- + \ No newline at end of file diff --git "a/Evaluare/Test Circuite Combina\310\233ionale/ALU/index.html" "b/Evaluare/Test Circuite Combina\310\233ionale/ALU/index.html" index c39d73a..f536913 100644 --- "a/Evaluare/Test Circuite Combina\310\233ionale/ALU/index.html" +++ "b/Evaluare/Test Circuite Combina\310\233ionale/ALU/index.html" @@ -4,13 +4,13 @@ ALU | Computer Architecture - +
Skip to main content

ALU

Implementați un ALU.

Intările ALU sunt:

  • i_w_op1 - primul operand (4 biți)
  • i_w_op2 - al doilea operand (4 biți)
  • i_w_opsel - operația selectată pentru a fi executată de către ALU (2 biți)

Ieșirea ALU este:

  • o_w_out - rezultatul operației între cei doi operanzi (4 biți)

Apăsați butonul "evaluate" din VPL pentru a afla operațile pe care trebuie sa le implementați pentru fiecare valoare a intrării i_w_opsel.

Operatiile posibile sunt:

  • ADDITION - Adunare între cei doi operanzi
  • SUBTRACTION - Scaderea celui de al doilea operand din primul operand
  • MULTIPLY - Înmulțirea celor doi operanzi și reținerea în rezultat a celor mai puți semnificativi 4 biți
  • DIVIDE - Împărțirea primului operand de către al doilea operand
  • MODULUS - Restul împărțirii primului operand de către al doilea operand
  • LEFT_SHIFT - Shiftarea la stânga a primului operand cu valoarea celui de al doilea operand
  • RIGHT_SHIFT - Shiftarea la dreapta a primului operand cu valoarea celui de al doilea operand
  • ARITHMETIC_RIGHT_SHIFT -Shiftarea aritmetică la dreapta a primului operand cu valoarea celui de al doilea operand
  • BITWISE_NAND - ȘI-NU între biți celor doi operanzi pe aceleași poziții
  • BITWISE_NOR - SAU_NU între biți celor doi operanzi pe aceleași poziții
  • BITWISE_AND - ȘI între biți celor doi operanzi pe aceleași poziții
  • BITWISE_OR - SAU între biți celor doi operanzi pe aceleași poziții
  • BITWISE_XOR - SAU-EXCLUSIV între biți celor doi operanzi pe aceleași poziții
  • COMPARE_EQUAL - Dacă cei doi operazi sunt egali rezultatul va avea valoarea 4'd1 astfel 4'd0.
  • COMPARE_LESS_THAN - Dacă primul operand este mai mic ca al doilea operand rezultatul va avea valoarea 4'd1 astfel 4'd0.
  • COMPARE_GREATER_THAN - Dacă primul operand este mai mare ca al doilea operand rezultatul va avea valoarea 4'd1 astfel 4'd0.
- + \ No newline at end of file diff --git "a/Evaluare/Test Circuite Combina\310\233ionale/True Table/index.html" "b/Evaluare/Test Circuite Combina\310\233ionale/True Table/index.html" index 4da739b..2299664 100644 --- "a/Evaluare/Test Circuite Combina\310\233ionale/True Table/index.html" +++ "b/Evaluare/Test Circuite Combina\310\233ionale/True Table/index.html" @@ -4,13 +4,13 @@ True Table | Computer Architecture - +
Skip to main content

True Table

Implmentați modulul verilog pentru tabelul de adevăr dat.

Veți avea 3 intrări:

  • i_w_a
  • i_w_b
  • i_w_c

Veți avea o singură ieșire:

  • o_w_out

Apăsați butonul "evaluate" din VPL pentru a afla tabelul de adevăr pe care trebuie să îl implementați.

Exemplu de tabel:

i_w_ai_w_bi_w_co_w_out
0001
0011
0101
0110
1000
1010
1100
1110
- + \ No newline at end of file diff --git "a/Evaluare/Test Circuite Combina\310\233ionale/index.html" "b/Evaluare/Test Circuite Combina\310\233ionale/index.html" index 3828fa5..8a7e26b 100644 --- "a/Evaluare/Test Circuite Combina\310\233ionale/index.html" +++ "b/Evaluare/Test Circuite Combina\310\233ionale/index.html" @@ -4,13 +4,13 @@ Test Circuite Combinaționale | Computer Architecture - +
Skip to main content

Test Circuite Combinaționale

- + \ No newline at end of file diff --git "a/Evaluare/Test Circuite Secven\310\233iale/FSM/index.html" "b/Evaluare/Test Circuite Secven\310\233iale/FSM/index.html" index 1e24c13..d6e1556 100644 --- "a/Evaluare/Test Circuite Secven\310\233iale/FSM/index.html" +++ "b/Evaluare/Test Circuite Secven\310\233iale/FSM/index.html" @@ -4,13 +4,13 @@ FSM | Computer Architecture - +
Skip to main content

FSM

Se dorește proiectarea unui FSM capabil să recunoască o SECVENTA de caractere data.

FSM va avea ca intrări:

  • i_w_in pe 2 biti, valoarea 2'd0 reprezinta caracterul 'a', 2'd1 caracterul 'b', 2'd2 caracterul 'c', 2'd3 caracterul 'd'
  • i_w_clk - ceas
  • i_w_reset - reset (activ 0) va reseta starea automatului

FSM va avea ca iesire:

  • o_w_out - daca sirul primit la intrare pana in acest moment respecta SECVENTA data.

Veti afla SECVENTA de caractere dupa apasarea butonului "evaluate" din VPL.

SECVENTA poate sa fie o expresie regulata formata dintr-un singur grup si un singur operator special, exemple:

  • a(bc)+
  • a(ab)*
- + \ No newline at end of file diff --git "a/Evaluare/Test Circuite Secven\310\233iale/Flag RAM/index.html" "b/Evaluare/Test Circuite Secven\310\233iale/Flag RAM/index.html" index b1e3599..9bd428e 100644 --- "a/Evaluare/Test Circuite Secven\310\233iale/Flag RAM/index.html" +++ "b/Evaluare/Test Circuite Secven\310\233iale/Flag RAM/index.html" @@ -4,13 +4,13 @@ FLAG-RAM | Computer Architecture - +
-
Skip to main content

FLAG-RAM

Implementati un modul ce va contine o memorie RAM (4 biti de adresare si 4 biti de date) si un registru de flag-uri ce va contine informatii despre ultimul cuvant citit din memoria RAM. Modulul ram este dat si prezent in fisierul "ram.v" (NU MODIFICATI, DOAR INSTANTIATI IN MODULUL VOSTRU). O implementare de registrul este prezenta in fisierul "register.v" (Folosirea lui este optionala).

Modulul de implementat are urmatoarele intrari:

  • i_w_clk - ceas
  • i_w_address - adresa de memorie ram (4 biti)
  • i_w_data - data de intrare (4 biti)
  • i_w_we - daca se scrie in RAM
  • i_w_oe - daca se afiseaza din RAM
  • i_w_flags_out - daca se afiseaza valorea registrului flag (activ pozitiv 1'b1)

Ieșirea modulului este:

  • o_w_out - datele citite din RAM sau valoarea registrului flag (4 biti)

Ordinea de prioritate a operaților este (i_w_we > i_w_oe > i_w_flags_out).

Registrul flag va avea 4 biti si va avea de implementat 4 flag-uri. Veti afla flag-urile de implementat si pozitia lor dupa apasarea butonului "evaluate" din VPL.

Flag-uri posibile:

  • Z - if all bits are unset
  • S - if the sign bit is set (MSB)
  • E - if it has an even number of bits set
  • O - if it has an odd number of bits set
  • C2 - if the bit on the position 2 is clear
  • S2 - if the bit on the position 2 is set
  • G4 - if the data value is greater than 4
  • L4 - if the data value is lower than 4
  • POW - if the data value is a power of 2 (1,2,4,8)
  • SMAX - if the data value is the maximum signed value
  • SMIN - if the data value is the minimum signed value
  • MAX - if the data value is the maximum unsigned value
  • PAL - if the data value is a binary palindrome (0110 -1, 1010-0)
  • SB2 - if there are at least 2 consecutive bits set (1100-1, 0101-0)
- +
Skip to main content

FLAG-RAM

Implementati un modul ce va contine o memorie RAM (4 biti de adresare si 4 biti de date) si un registru de flag-uri ce va contine informatii despre ultimul cuvant citit din memoria RAM. Modulul ram este dat si prezent in fisierul "ram.v" (NU MODIFICATI, DOAR INSTANTIATI IN MODULUL VOSTRU). O implementare de registrul este prezenta in fisierul "register.v" (Folosirea lui este optionala).

Modulul de implementat are urmatoarele intrari:

  • i_w_clk - ceas
  • i_w_address - adresa de memorie ram (4 biti)
  • i_w_data - data de intrare (4 biti)
  • i_w_we - daca se scrie in RAM
  • i_w_oe - daca se afiseaza din RAM
  • i_w_flags_out - daca se afiseaza valorea registrului flag (activ pozitiv 1'b1)

Ieșirea modulului este:

  • o_w_out - datele citite din RAM sau valoarea registrului flag (4 biti)

Ordinea de prioritate a operaților este (i_w_we > i_w_oe > i_w_flags_out).

Registrul flag va avea 4 biti si va avea de implementat 4 flag-uri. Veti afla flag-urile de implementat si pozitia lor dupa apasarea butonului "evaluate" din VPL.

Flag-uri posibile:

  • Z - if all bits are unset
  • S - if the sign bit is set (MSB)
  • E - if it has an even number of bits set
  • O - if it has an odd number of bits set
  • C2 - if the bit on the position 2 (counting starts from 0, from right to left) is clear (4'b0101 - 0, 4'b1010 - 1)
  • S2 - if the bit on the position 2 (counting starts from 0, from right to left) is set (4'b0101 - 1, 4'b1010 - 0)
  • G4 - if the data value is greater than 4
  • L4 - if the data value is lower than 4
  • POW - if the data value is a power of 2 (1,2,4,8)
  • SMAX - if the data value is the maximum signed value
  • SMIN - if the data value is the minimum signed value
  • MAX - if the data value is the maximum unsigned value
  • PAL - if the data value is a binary palindrome (0110 -1, 1010-0)
  • SB2 - if there are at least 2 consecutive bits set (1100-1, 0101-0)
+ \ No newline at end of file diff --git "a/Evaluare/Test Circuite Secven\310\233iale/Operation Register/index.html" "b/Evaluare/Test Circuite Secven\310\233iale/Operation Register/index.html" index 5d0cf8d..f4c2dc9 100644 --- "a/Evaluare/Test Circuite Secven\310\233iale/Operation Register/index.html" +++ "b/Evaluare/Test Circuite Secven\310\233iale/Operation Register/index.html" @@ -4,13 +4,13 @@ Operation Register | Computer Architecture - +
Skip to main content

Operation Register

Sa se implementeze un registru multifunctional.

Intrarile registrului sunt:

  • i_w_clk - ceas
  • i_w_reset - reset (activ pe 0)
  • i_w_data - date de intrare (4 biți)
  • i_w_we - daca se scrie in registru
  • i_w_oe - daca se afiseaza in registru
  • i_w_opsel - selectie asupra unui operatii pe registru (2 biți)

Iesirea registrului este:

  • o_w_out este activa doar cand i_w_oe este activ (1), altfel o_w_out va avea valoarea 4'b0000. (4 biți)

Prioritatea funcțiilor registrului sunt: i_w_we, i_w_oe, i_w_opsel. (daca i_w_we si i_w_oe sunt active in acelasi timp se va face doar scrierea in registru a valorii i_w_data)

Operatiile pe care va trebui sa le implementati in functie de valoarea i_w_opsel le veti afla doar dupa apasarea butonului "evaluate" din VPL.

Operatiile posibile sunt:

  • SHR1 - Shift right by one
  • SHL1 - Shift left by one
  • SAR1 - Shift right arithmetic by one
  • ROTR1 - Rotate right by one
  • ROTL1 - Rotate left by one
  • REDUCE_BITWISE_OR - OR all bits
  • REDUCE_BITWISE_XOR - XOR all bits
  • REDUCE_BITWISE_AND - AND all bits
  • NEG - Two's complement
  • NOT - One's Complement
  • INC - Increment by one
  • DEC - Decrement by one
- + \ No newline at end of file diff --git "a/Evaluare/Test Circuite Secven\310\233iale/index.html" "b/Evaluare/Test Circuite Secven\310\233iale/index.html" index b73be86..bf3b173 100644 --- "a/Evaluare/Test Circuite Secven\310\233iale/index.html" +++ "b/Evaluare/Test Circuite Secven\310\233iale/index.html" @@ -4,13 +4,13 @@ Test Circuite Secvențiale | Computer Architecture - +
Skip to main content

Test Circuite Secvențiale

- + \ No newline at end of file diff --git a/Evaluare/index.html b/Evaluare/index.html index 82523f7..60e8ea2 100644 --- a/Evaluare/index.html +++ b/Evaluare/index.html @@ -4,13 +4,13 @@ Evaluare | Computer Architecture - +
Skip to main content

Evaluare

- + \ No newline at end of file diff --git a/Laboratoare/0 Recapitulare/Automate finite/Teorie/index.html b/Laboratoare/0 Recapitulare/Automate finite/Teorie/index.html index 5f12473..46d6538 100644 --- a/Laboratoare/0 Recapitulare/Automate finite/Teorie/index.html +++ b/Laboratoare/0 Recapitulare/Automate finite/Teorie/index.html @@ -4,7 +4,7 @@ Automate finite | Computer Architecture - + @@ -15,7 +15,7 @@ Dacă ne aflăm în starea ''SA'' și automatul primește la intrare valoarea:
  • 0 (caracterul "a") - automatul va trece în starea ''Sa'' care ne spune că intrarea precedentă a fost "a", însă nu vom activa ieșirea automatului deoarece automatul nu a văzut și caracterul "b"
  • 1 (caracterul "b") - automatul va trece în starea ''Sb'' care ne spune că intrarea precedentă a fost "b"

    • În momentul de față comportamentul automatului a fost descris complet, toate cele 4 stări identificate având definite tranzițiile pentru toate combinațiile semnalelor de intrare. Figura de mai jos prezintă diagrama de stări a automatului.

    Automatul de recunoaștere a secvenței &quot;ba&quot;

    Figure: Automatul de recunoaștere a secvenței "ba"

    O dată determinată diagrama de stări a automatului, putem trece la implementarea acestuia într-un limbaj cunoscut (C/C++/C#/Java):

    void FSM_ba() {  
      // FSM input: 0 - a, 1 - b, other - exit
      // FSM output: 0 - not found, 1 - found
      // FSM state: 0 - S0, 1 - Sa, 2 - Sb, 3 - SA
      int state = 0;
      int in, out;
      out = 0;
      in = 0;

      while(1) {
          switch(state) {
              case 0:
                  out = 0;
                  break;

              case 1:
                  out = 0;
                  break;

              case 2:
                  out = 0;
                  break;

              case 3:
                  out = 1;
                  break;
          }
        std::cout << "Output: " << out << std::endl;
          
        // Read input
        std::cout << "Please input a number (0 for a, 1 for b, other exit ): ";
        std::cin >> in;
        if (in > 1) {
            break;
        }

          switch(state) {
              case 0:
                  if(in == 0)
                      state = 1;
                  else
                      state = 2;
                  break;

              case 1:
                  if(in == 0)
                      state = 1;
                  else
                      state = 2;
                  break;

              case 2:
                  if(in == 0)
                      state = 3;
                  else
                      state = 2;
                  break;

              case 3:
                  if(in == 0)
                      state = 1;
                  else
                      state = 2;
                  break;
          }
      }
    }

    Codul sursa pentru functia FSM_ba

    Intersecție semaforizată​

    Se dorește modelarea prin intermediul unui automat de stări a unei intersecții semaforizate în care mașinile pot intra din nord (N), est (E), sud(S) sau vest (W). Semaforul din nord este sincronizat cu semaforul din sud, iar cel din est este sincronizat cu cel din vest. Duratele de timp pentru cele două direcții vor fi: Nord - Sud: roșu - 40 sec, galben - 10sec, verde - 50sec; Est-Vest: roșu - 60 sec, galben - 10 sec, verde - 30 sec.

    Vom începe proiectarea automatului prin identificarea intrărilor și ieșirilor. Deoarece descrierea informală nu conține informații despre intrările și ieșirile necesare vom folosi oricâte intrări și ieșiri avem nevoie pentru implementarea comportamentului. Un minim de ieșiri pentru automat reprezintă semnalele de comandă pentru culorile semaforului pentru pietoni și pentru mașini. Cele 5 semnale vor fi:

    Diagrama de stări a automatului va urmări tranziția celor 3 culori ale semaforului pentru mașini: verde -> galben -> roșu -> verde .

    Automatul intersecției

    Figure: Automatul intersecției

    Odată determinată diagrama de stări a automatului, putem trece la implementarea acestuia într-un limbaj cunoscut (C/C++/C#/Java): 

    void FSM_intersectie() {
        int state = 0; // FSM state: 0 - N/S_verde, 1 - N/S_galben, 2 - N/S_rosu, 3 - E/W_galben
        int N_rosu;
        int N_galben;
        int N_verde;
        int S_rosu;
        int S_galben;
        int S_verde;
        int W_rosu;
        int W_galben;
        int W_verde;
        int E_rosu;
        int E_galben;
        int E_verde;
        int done;
        int T;
        done = 0;
        T = 0;

        while(1) {
            N_rosu = 0;
            N_galben = 0;
            N_verde = 0;
            S_rosu = 0;
            S_galben = 0;
            S_verde = 0;
            W_rosu = 0;
            W_galben = 0;
            W_verde = 0;
            E_rosu = 0;
            E_galben = 0;
            E_verde = 0;
            switch(state) {
                case 0:
                    E_rosu = 1;
                    W_rosu = 1;
                    N_verde = 1;
                    S_verde = 1;
                    T = 50;
                    if(done == 1)
                        state = 1;
                    else
                        state = 0;
                    break;
                case 1:
                    N_galben = 1;
                    S_galben = 1;
                    E_rosu = 1;
                    W_rosu = 1;
                    T = 10;
                    if(done == 1)
                        state = 2;
                    else
                        state = 1;
                    break;
                case 2:
                    N_rosu = 1;
                    S_rosu = 1;
                    E_verde = 1;
                    W_verde = 1;
                    T = 30;
                    if(done == 1)
                        state = 3;
                    else
                        state = 2;
                    break;
                case 3:
                    N_rosu = 1;
                    S_rosu = 1;
                    E_galben = 1;
                    W_galben = 1;
                    T = 10;
                    if(done == 1)
                        state = 0;
                    else
                        state = 3;
                    break;
            }

            std::cout << "Stare: " << state << std::endl;
            std::cout << "Done: " << done << std::endl;
            std::cout << "N: " << N_rosu << N_galben << N_verde << std::endl;
            std::cout << "S: " << S_rosu << S_galben << S_verde << std::endl;
            std::cout << "W: " << W_rosu << W_galben << W_verde << std::endl;
            std::cout << "E: " << E_rosu << E_galben << E_verde << std::endl;
            std::cout << "Timp: " << T << std::endl;
            std::cin >> done;
            if (done > 1) {
                break;
            }
        }
    }

    Codul sursa pentru functia FSM_intersectie

    - + \ No newline at end of file diff --git a/Laboratoare/0 Recapitulare/Automate finite/index.html b/Laboratoare/0 Recapitulare/Automate finite/index.html index 04e26f6..d3540c4 100644 --- a/Laboratoare/0 Recapitulare/Automate finite/index.html +++ b/Laboratoare/0 Recapitulare/Automate finite/index.html @@ -4,13 +4,13 @@ Automate finite | Computer Architecture - +
    Skip to main content

    Automate finite

    - + \ No newline at end of file diff --git a/Laboratoare/0 Recapitulare/Bistabil D/Teorie/index.html b/Laboratoare/0 Recapitulare/Bistabil D/Teorie/index.html index 18e0778..6ec0bbb 100644 --- a/Laboratoare/0 Recapitulare/Bistabil D/Teorie/index.html +++ b/Laboratoare/0 Recapitulare/Bistabil D/Teorie/index.html @@ -4,13 +4,13 @@ Bistabilul D | Computer Architecture - +
    Skip to main content

    Bistabilul D

    Elementele de memorare din circuitele secvențiale pot fi implementate prin bistabile (eng. flip-flops). Acestea stochează valori în funcție de valoarea de la intrare și de semnalul de ceas. Valoarea stocată poate fi schimbată doar atunci când ceasul realizează o tranziție activă (un semnal de ceas poate fi "activ" pe front crescător (eng. rising edge) sau pe front descrescător (eng. falling edge)).

    Există 4 tipuri principale de bistabile: D, T, SR și JK, iar în acest laborator ne vom axa pe bistabilul D. Acesta are un design simplu și este folosit în general pentru implementarea registrelor din procesoare (cea mai mică și mai rapidă unitate de stocare din ierarhia de memorie).

    Diagrama bloc pentru bistabilul D

    Figure: Diagrama bloc pentru bistabilul D

    Intrările și ieșirile circuitului sunt:

    • ''D'' - valoarea (data) de stocat
    • ''clk'' - semnalul de ceas, considerat activ pe front crescător în descrierile următoare
    • ''Q'' - starea curentă
    • ''!Q'' - starea curentă negată

    Ca mod de funcționare, ecuația caracteristică a sa este ''Qnext = D'', adică starea următoare (''Qnext'') a bistabilului depinde doar de intrarea ''D'', fiind independentă de starea curentă (''Q''), după cum se observă și din tabelul de mai jos.

    DQQnext
    000
    010
    101
    111

    Table: Tabelul de tranziții pentru bistabilul D

    Pentru a înțelege mai ușor comportamentul bistabilelor, pe lângă tabelele de tranziții mai sunt utile și diagramele de semnale (eng. timing diagrams), cum este cea din figura de mai jos, unde se poate observa cum ieșirea ''Q'' se schimbă doar pe frontul crescător de ceas și devine egală cu intrarea ''D'' în momentul tranziției ceasului.

    Diagrama de semnale pentru bistabilul D

    Figure: Diagrama de semnale pentru bistabilul D

    - + \ No newline at end of file diff --git a/Laboratoare/0 Recapitulare/Bistabil D/index.html b/Laboratoare/0 Recapitulare/Bistabil D/index.html index 967b39e..dc10bd5 100644 --- a/Laboratoare/0 Recapitulare/Bistabil D/index.html +++ b/Laboratoare/0 Recapitulare/Bistabil D/index.html @@ -4,13 +4,13 @@ Bistabil D | Computer Architecture - +
    Skip to main content

    Bistabil D

    - + \ No newline at end of file diff --git "a/Laboratoare/0 Recapitulare/Circuite combina\310\233ionale/Teorie/index.html" "b/Laboratoare/0 Recapitulare/Circuite combina\310\233ionale/Teorie/index.html" index 86e771a..0254d4c 100644 --- "a/Laboratoare/0 Recapitulare/Circuite combina\310\233ionale/Teorie/index.html" +++ "b/Laboratoare/0 Recapitulare/Circuite combina\310\233ionale/Teorie/index.html" @@ -4,13 +4,13 @@ Circuite combinaționale | Computer Architecture - +
    Skip to main content

    Circuite combinaționale

    Circuitele logice combinaționale aplică funcții logice pe semnalele de intrare pentru a obține semnalele de ieșire. Valorile de ieșire depind doar de valorile de intrare, iar când starea unei intrări se schimbă, acest lucru se reflectă imediat la ieșirile circuitului.

    Diagrama bloc pentru un circuit combinațional cu n intrări și m ieșiri

    Figure:Diagrama bloc pentru un circuit combinațional cu n intrări și m ieșiri

    Logica combinațională poate fi reprezentată prin:

    • diagrame structurale la nivel de porți logice
    • tabele de adevăr
    • expresii booleene (funcții logice)

    Circuitele combinaționale sunt folosite în procesoare în cadrul componentelor de calcul, iar cele mai des întâlnite sunt:

    • multiplexoarele și demultiplexoarele
    • codificatoarele și decodificatoarele
    • sumatoarele
    • comparatoarele
    • memoriile ROM (read-only, nu păstrează stare)

    Un exemplu de folosire a sumatoarelor este în cadrul Unităților Aritmetice-Logice (UAL) din interiorul procesoarelor.

    - + \ No newline at end of file diff --git "a/Laboratoare/0 Recapitulare/Circuite combina\310\233ionale/index.html" "b/Laboratoare/0 Recapitulare/Circuite combina\310\233ionale/index.html" index 4a29026..318a1a5 100644 --- "a/Laboratoare/0 Recapitulare/Circuite combina\310\233ionale/index.html" +++ "b/Laboratoare/0 Recapitulare/Circuite combina\310\233ionale/index.html" @@ -4,13 +4,13 @@ Circuite combinaționale | Computer Architecture - +
    Skip to main content

    Circuite combinaționale

    - + \ No newline at end of file diff --git "a/Laboratoare/0 Recapitulare/Circuite secven\310\233iale/Teorie/index.html" "b/Laboratoare/0 Recapitulare/Circuite secven\310\233iale/Teorie/index.html" index 6ccaaa6..82341f9 100644 --- "a/Laboratoare/0 Recapitulare/Circuite secven\310\233iale/Teorie/index.html" +++ "b/Laboratoare/0 Recapitulare/Circuite secven\310\233iale/Teorie/index.html" @@ -4,13 +4,13 @@ Circuite secvențiale | Computer Architecture - +
    Skip to main content

    Circuite secvențiale

    Spre deosebire de circuitele logice combinaționale, cele secvențiale (eng: sequential logic) nu mai depind exclusiv de valoarea curentă a intrărilor, ci și de stările anterioare ale circuitului.

    Logica secvențială poate fi de două tipuri: sincronă și asincronă. În primul caz, cel cu care vom lucra și la laborator, este folosit un semnal de ceas care comandă elementul/elementele de memorare, acestea schimbându-și starea doar la impulsurile de ceas. În al doilea caz, ieșirile se modifică atunci când se modifică și intrările, neexistând un semnal de ceas pentru elementele de memorare. Circuitele secvențiale asincrone sunt mai greu de proiectat deoarece pot apărea probleme de sincronizare. Din această cauză ele sunt folosite mai rar.

    În continuare ne vom referi doar la circuitele secvențiale sincrone.

    Schema bloc a unui circuit secvențial sincron

    Figure: Schema bloc a unui circuit secvențial sincron

    - + \ No newline at end of file diff --git "a/Laboratoare/0 Recapitulare/Circuite secven\310\233iale/index.html" "b/Laboratoare/0 Recapitulare/Circuite secven\310\233iale/index.html" index 30576d5..d910ecc 100644 --- "a/Laboratoare/0 Recapitulare/Circuite secven\310\233iale/index.html" +++ "b/Laboratoare/0 Recapitulare/Circuite secven\310\233iale/index.html" @@ -4,13 +4,13 @@ Circuite secvențiale | Computer Architecture - +
    Skip to main content

    Circuite secvențiale

    - + \ No newline at end of file diff --git a/Laboratoare/0 Recapitulare/Porti logice/Teorie/index.html b/Laboratoare/0 Recapitulare/Porti logice/Teorie/index.html index 4edbeab..cb21bec 100644 --- a/Laboratoare/0 Recapitulare/Porti logice/Teorie/index.html +++ b/Laboratoare/0 Recapitulare/Porti logice/Teorie/index.html @@ -4,13 +4,13 @@ Porți logice | Computer Architecture - +
    Skip to main content

    Porți logice

    Porțile logice reprezintă componentele de bază disponibile în realizarea circuitelor combinaționale. Ele oglindesc operațiile din algebra booleană, algebră care stă la baza teoriei circuitelor combinaționale. În sunt prezentate cele mai întâlnite porți logice împreună cu operația booleană pe care o implementează.

    DenumireSimbolOperatorabf
    Inversor (NOT)NOT Gatef = !a01
    10
    Poarta SAU (OR)OR Gatef = a || b000
    011
    101
    111
    Poarta ŞI (AND)AND Gatef = a && b000
    010
    100
    111
    Poarta SAU-NU (NOR)NOR Gatef = !(a || b)001
    010
    100
    110
    Poarta ŞI-NU (NAND)NAND Gatef = !(a && b)001
    011
    101
    110
    Poarta SAU EXCLUSIV (XOR)XOR Gatef = a ^ b000
    011
    101
    110
    Poarta SAU EXCLUSIV NU (XNOR)XNOR Gatef = !(a ^ b)001
    010
    100
    111

    Table: Tabel de adevăr pentru porti logice elementare

    Multiplexorul 4:1​

    Un multiplexor digital este un circuit combinațional care implementează o funcție de selecție a uneia dintre intrările sale.

    • 2n2^n intrări
    • nn intrări de selecție
    • o ieșire

    Diagrama bloc a multiplexorului 4:1

    Figure: Diagrama bloc a multiplexorului 4:1

    Schema logică a multiplexorului 4:1

    Figure: Schema logică a multiplexorului 4:1

    Alegerea semnalului de ieșire se face pe baza intrărilor de selecție, care reprezintă în baza 2 numărul intrării ce trebuie selectate. În exemplul din imaginea de mai sus avem schema bloc a unui multiplexor cu 4 intrări, iar acesta are nevoie de două intrări de selecție.

    Funcția inversă a multiplexorului este realizată de către circuitele de demultiplexare, care preiau un semnal de intrare și folosesc intrările de selecție pentru a-l transmite pe una din ieșirile posibile.

    S2S1out
    00I1
    01I2
    10I3
    11I4

    Table: Tabel de adevăr pentru multiplexorul 4:1

    Deoarece multiplexorul 4:1 are 6 intrări, tabelul de adevăr devine destul de mare și nu mai este indicat de pornit de la acesta pentru obținerea funcției logice. Din descrierea funcționării circuitului și proprietățile porții AND, putem deduce termenii formulei:

    f=sˉ1 ⋅ sˉ2 ⋅ I1 + s1 ⋅sˉ2 ⋅ I2 + sˉ1 ⋅ s2 ⋅ I3 + s1 ⋅ s2 ⋅ I4f = \bar s_1\ \cdotp\ \bar s_2\ \cdotp\ I_1\ +\ s_1\ \cdotp \bar s_2\ \cdotp\ I_2\ +\ \bar s_1\ \cdotp\ s_2\ \cdotp\ I_3\ +\ s_1\ \cdotp\ s_2\ \cdotp\ I_4

    Conform formulei se poate realiza circuitul cu porți logice din imaginea de mai sus.

    int mux4to1(int s0, int s1, int i0, int i1, int i2, int i3) {
        // Use the select value to choose the appropriate input
        switch ((s1 << 1) | s0) {  // Combine s0 and s1 into a 2-bit value
            case 0:
                return i0; // If s1 and s0 are both 0, return input i0
            case 1:
                return i1;
            case 2:
                return i2;
            case 3:
                return i3;
            default:
                return 0; // Default case (should never be reached)
        }
    }

    Codul sursa pentru functia mux4to1

    - + \ No newline at end of file diff --git a/Laboratoare/0 Recapitulare/Porti logice/index.html b/Laboratoare/0 Recapitulare/Porti logice/index.html index d338ec2..289fd0e 100644 --- a/Laboratoare/0 Recapitulare/Porti logice/index.html +++ b/Laboratoare/0 Recapitulare/Porti logice/index.html @@ -4,13 +4,13 @@ Porti logice | Computer Architecture - +
    Skip to main content

    Porti logice

    - + \ No newline at end of file diff --git a/Laboratoare/0 Recapitulare/Sumatoare/Teorie/index.html b/Laboratoare/0 Recapitulare/Sumatoare/Teorie/index.html index 5b8a782..668642d 100644 --- a/Laboratoare/0 Recapitulare/Sumatoare/Teorie/index.html +++ b/Laboratoare/0 Recapitulare/Sumatoare/Teorie/index.html @@ -4,13 +4,13 @@ Sumatoare | Computer Architecture - +
    Skip to main content

    Sumatoare

    Sumatorul elementar​

    Sumatoarele (adders), folosite cel mai mult în unitățile aritmetice logice ale procesoarelor, realizează adunări pe un număr dat de biți, furnizând la ieșirea circuitului suma și transportul (carry) rezultat în urma operației.

    Există mai multe tipuri de sumatoare pentru adunarea numerelor pe n biți, iar acestea se bazează pe sumatoare simple de 1 bit, care pot fi de două tipuri:

    • sumatorul elementar parțial (Half adder) - însumează doi operanzi pe 1 bit și oferă la ieșire suma acestora și transportul.
    • sumatorul elementar complet (Full adder) - însumează doi operanzi pe 1 bit și un transport și oferă la ieșire suma acestora și transportul.

    Diagrama bloc pentru half adder

    Figure: Diagrama bloc pentru half adder

    Diagrama bloc pentru full adder

    Figure: Diagrama bloc pentru full adder

    Diagrama semnale pentru full adder

    Figure: Diagrama semnale pentru full adder

    Sumatorul elementar parțial​

    Acest sumator este în continuare descris prin expresiile booleene, tabelul de adevăr și schema logică.

    absumc_out
    0000
    0110
    1010
    1101

    Table: Tabelul de adevăr pentru sumatorul elementar parțial

    Din tabelul de adevăr se pot deduce următoarele formule:

    sum   = a ^  b
    c_out = a && b

    Conform acestor formule putem exprima circuitul prin porți logice, ca în imaginea de mai jos:

    Schema logică pentru half adder

    Figure: Schema logică pentru half adder

    Dintr-un tabel de adevăr, pentru fiecare output se va deduce o funcție/expresie aplicând următoarele reguli:

    • fiecare rând din tabel pentru care funcția are valoarea 1 va genera un termen
    • termenii sunt formați din parametrii funcției legați prin ȘI
      • dacă parametrul are valoarea 1 se consideră în formă directă
      • dacă parametrul are valoarea 0 se consideră în formă negată
    • se aplică SAU între toți termenii deduși

    Pentru sumatorului elementar parțial avem:

    sum = aˉ ⋅ b + a ⋅ bˉsum\ =\ \bar a\ \cdotp\ b\ +\ a\ \cdotp\ \bar b

    carry = a ⋅ bcarry\ =\ a\ \cdotp \ b

    void half_adder(const int a, const int b, int &sum, int &carry) {
        sum = a ^ b;       // Sum is the XOR of the inputs
        carry = a & b;     // Carry is the AND of the inputs
    }

    Codul sursa pentru functia half_adder

    În multe cazuri aceste formule sunt prea complexe, conținând multe operații și necesitând multe porți logice pentru a fi implementate. Pentru a reduce complexitatea formulelor rezultate se poate aplica un procedeu de minimizare, care va reduce dimensiunea termenilor sau chiar îi va elimina. Minimizarea se poate realiza folosind teoremele algebrei booleene sau grafic, prin diagrame Karnaugh.

    Sumatorul elementar complet​

    abc_insumc_out
    00000
    01010
    10010
    11001
    00110
    01101
    10101
    11111

    Table: Tabelul de adevăr pentru full adder

    Din tabelul de adevăr se pot deduce următoarele formule:

    sum   =   a ^ b  ^  c_in
    c_out = ((a ^ b) && c_in) || (a && b)

    Conform acestor formule putem exprima circuitul prin porți logice sau putem folosi sumatoare elementare parțiale, ca în imaginea de mai jos:

    Schema logică pentru full adder

    Figure: Schema logică pentru full adder

    void full_adder(const int a, const int b, const int cin, int &sum, int &carry)
    {
        sum   =   a ^ b  ^  c_in;
        carry = ((a ^ b) && c_in) || (a && b);
    }

    Sau utilizand sumatoare elementare partiale:

    void full_adder(const int a, const int b, const int cin, int &sum, int &carry) {
        int sum1, carry1, carry2;

        // First half adder
        half_adder(a, b, sum1, carry1);

        // Second half adder
        half_adder(sum1, cin, sum, carry2);

        // Final carry
        carry = carry1 | carry2;
    }

    Codul sursa pentru functia full_adder

    Sumatorul cu transport succesiv​

    Cel mai intuitiv mod de a forma un sumator este de a lega în cascadă mai multe sumatoare elementare complete pe 1 bit. În acest fel se formează un sumator cu transport succesiv (eng. ripple-carry adder), cum este cel pe 4 biți din imaginea de mai jos, care primește la intrare a[3:0], b[3:0], c_in și are ca ieșiri suma s[3:0] și transportul c_out. În cazul sumatoarelor pe mai mulți biți nu mai este indicat de pornit întâi de la o tabelă de adevăr deoarece aceasta ajunge la dimensiuni prea mari.

    Schema sumatorului cu transport succesiv, pe 4 biți

    Figure: Schema sumatorului cu transport succesiv, pe 4 biți

    template <int N>
    void ripple_adder(const int (&a)[N], const int (&b)[N], int (&sum)[N], const int carry_in, int &carry_out) {
        // Initialize carry to 0
        int carry_tmp[N+1];
        carry_tmp[0] = carry_in;

        // Iterate over each bit
        for (int i = 0; i < N; ++i) {
            // Calculate the sum and carry for the current bit
            full_adder(a[i], b[i], carry_tmp[i], sum[i], carry_tmp[i+1]);
        }

        // Set the final carry
        carry_out = carry_tmp[N];
    }

    Codul sursa pentru functia ripple_adder

    Un alt avantaj al acestui design simplu, este că se pot forma sumatoare pe mai mulți biți din înlănțuirea oricâtor sumatoare. De exemplu, pentru a însuma numere pe 16 biți se poate crea un sumator ripple-carry din legarea în cascadă a 4 sumatoare pe 4 biți, ca în imaginea de mai jos.

    Schema sumatorului cu transport succesiv, pe 16 biți

    Figure: Schema sumatorului cu transport succesiv, pe 16 biți

    Deși are un design simplu, dezavantajul acestui sumator este că este **lent**, fiecare sumator elementar necesitând transportul de la sumatorul precedent. Există alte sumatoare, cum ar fi cel cu transport anticipat (eng. [Carry-lookahead adder](http://www.eng.ucy.ac.cy/theocharides/Courses/ECE210/Carrylookahead_supp4.pdf) ), care oferă o funcționare mai rapidă, eliminând așteptarea propagării transportului.
    // Example for 16-bit ripple adder using four 4-bit ripple adders
    const int M = 16;
    int a16[M] = {1, 0, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1, 0, 0}; // Example 16-bit binary number
    int b16[M] = {1, 1, 0, 1, 0, 0, 1, 1, 1, 1, 0, 1, 0, 0, 1, 1}; // Example 16-bit binary number
    int sum16[M];
    int carry16[5] = {0}; // Carry array for each 4-bit adder

    for (int i = 0; i < M; i += 4) {
        ripple_adder<4>(*(int(*)[4])(a16 + i), *(int(*)[4])(b16 + i), *(int(*)[4])(sum16 + i), carry16[i / 4], carry16[i / 4 + 1]);
    }

    Codul sursa

    - + \ No newline at end of file diff --git a/Laboratoare/0 Recapitulare/Sumatoare/index.html b/Laboratoare/0 Recapitulare/Sumatoare/index.html index a14e5c7..3590e16 100644 --- a/Laboratoare/0 Recapitulare/Sumatoare/index.html +++ b/Laboratoare/0 Recapitulare/Sumatoare/index.html @@ -4,13 +4,13 @@ Sumatoare | Computer Architecture - +
    Skip to main content

    Sumatoare

    - + \ No newline at end of file diff --git a/Laboratoare/0 Recapitulare/index.html b/Laboratoare/0 Recapitulare/index.html index 5feee71..0943323 100644 --- a/Laboratoare/0 Recapitulare/index.html +++ b/Laboratoare/0 Recapitulare/index.html @@ -4,13 +4,13 @@ 0 Recapitulare | Computer Architecture - +
    Skip to main content

    0 Recapitulare

    - + \ No newline at end of file diff --git "a/Laboratoare/1 Verilog Combina\310\233ional/Descriere structurala/Practic\304\203/index.html" "b/Laboratoare/1 Verilog Combina\310\233ional/Descriere structurala/Practic\304\203/index.html" index ab65587..60857c2 100644 --- "a/Laboratoare/1 Verilog Combina\310\233ional/Descriere structurala/Practic\304\203/index.html" +++ "b/Laboratoare/1 Verilog Combina\310\233ional/Descriere structurala/Practic\304\203/index.html" @@ -4,13 +4,13 @@ Practică: | Computer Architecture - +
    Skip to main content

    Practică:

    1. Sumator elementar complet, utilizând sumatoare elementare parțiale.​

    Soluția se află în repo-ul materiei GitHub. Implementarea unui sumator elementar parțial se poate găsi în fișierul halfadder.v, iar sumatorul elementar complet în fulladder.v. Observați modul în care sunt declarate sumatoarele elementare parțiale.

    halfadder l_m_halfadder_0( .o_w_s(l_w_s0), .o_w_cout(l_w_c0), .i_w_a(i_w_a), .i_w_b(i_w_b) );
    halfadder l_m_halfadder_1( .o_w_s(o_w_s), .o_w_cout(l_w_c1), .i_w_a(i_w_cin), .i_w_b(l_w_s0) );

    Pentru a crea proiectul putem folosi comanda make build. Pentru simulare make simluation și pentru a deschide întreg proiectul în Vivado și a avea posibilitatea de a încărca pe FPGA make vivado.

    2. Sumator pe 4 biți, cu două intrări și două ieșiri.​

    Soluția se află în repo-ul materiei GitHub. Rulați simulare (make simluation) și verificați corectitudinea sumatorului vizualizând semnalele în baza 10.

    3. Sumator pe 6 biți, cu două intrări și o ieșire.​

    Soluția se află în repo-ul materiei GitHub. Încărcați programul pe FPGA (make vivado), urmărind ghidul.

    4. Comparator pe un bit.​

    Acesta are două intrări și trei ieșiri (pentru mai mic, egal și mai mare). Soluția se află în repo-ul materiei GitHub. Simulați și încărcați pe FPGA.

    - + \ No newline at end of file diff --git "a/Laboratoare/1 Verilog Combina\310\233ional/Descriere structurala/Teorie/index.html" "b/Laboratoare/1 Verilog Combina\310\233ional/Descriere structurala/Teorie/index.html" index 928ac13..7a45444 100644 --- "a/Laboratoare/1 Verilog Combina\310\233ional/Descriere structurala/Teorie/index.html" +++ "b/Laboratoare/1 Verilog Combina\310\233ional/Descriere structurala/Teorie/index.html" @@ -4,13 +4,13 @@ Structura limbajului Verilog | Computer Architecture - +
    Skip to main content

    Structura limbajului Verilog

    În laboratorul curent ne vom concentra asupra asimilării limbajului Verilog, începând cu descrierea structurală a unui circuit combinațional.

    Atunci când proiectăm un circuit digital folosind un HDL, începem prin a face o descriere textuală a circuitului, adică scriem cod. Acesta este compilat, iar în urma procesului va rezulta un model al circuitului care poate fi apoi rulat într-un simulator cu scopul de a verifica funcționalitatea descrierii. O alternativă la simulare este folosirea unui utilitar de sintetizare, care preia codul HDL și generează fișiere de configurare pentru FPGA.

    Însă proiectarea circuitelor poate deveni complexă. Datorită acestui motiv, se preferă proiectarea de tip top-down, o modalitate de partiționare sistematică și repetată a unui sistem complex în unități funcționale mai simple, a căror implementare poate fi făcută mai facil. O partiționare și organizare la nivel înalt a unui sistem reprezintă arhitectura acestuia. Unitățile funcționale individuale ce rezultă în urma partiționării sunt mai ușor de proiectat și de testat decât întregul sistem. Strategia divide-et-impera a proiectării top-down ne permite proiectarea de circuite care conțin milioane de porți.

    Module​

    Modulul este unitatea de bază a limbajului Verilog, element ce încapsulează inferfața și comportamentul unui circuit. Modelul black-box este cel mai apropiat de definiția unui modul, întrucât se cunosc elementele de legătură: intrările și ieșirile din modul precum și funcționalitatea precisă a modulului, cu un accent mai redus asupra detaliilor de implementare și a modului în care acesta funcționează.

    Pentru declararea unui modul, se folosesc cuvintele cheie ''module'' și ''endmodule''. Pe lângă aceste cuvinte cheie, declarația unui modul mai conține:

    • numele acestuia,
    • lista de porturi (pentru interfața cu exteriorul): pot fi de intrare (input), ieșire (output) sau intrare - ieșire (inout) și pot avea unul sau mai mulți biți,
    • și, desigur, implementarea funcționalității modulului.

    Ordinea porturilor unui modul nu este restricționată. Intrările și ieșirile pot fi declarate în orice ordine, însă, pentru consistență, o regulă de bună practică este folosirea convenției (obligatorie la primitive): prima dată se declară ieșirile, apoi intrările.

    Exemplu declarare modul​

    module my_beautiful_module (
        output out,
        input [3:0] a, 
        input b);        
    /* descrierea funcționalității */
    endmodule

    Pentru implementarea modului avem la dispoziție câteva elemente, care sunt descrise în ceea ce urmează.

    Primitive​

    Element ce stă la baza descrierii structurale a circuitelor, primitiva este o funcție asociată unei porți logice de bază. Verilog are o suită de primitive predefinite:

    • primitive asociate porților logice: and, or, nand, nor, xor, xnor;
    • primitive asociate porților de transmisie: not, buf, etc;
    • primitive asociate tranzistorilor: pmos, tranif, etc.

    Fiecare primitivă are porturi, prin care este conectată în exterior. Primitivele predefinite oferă posibilitatea conectării mai multor intrări (ex. or, and, xor etc.) sau mai multor ieșiri (ex. buf, not). Folosirea unei primitive se face prin instanțierea sa cu lista de semnale care vor fi conectate la porturile ei. Pentru primitivele predefinite porturile de ieșire sunt declarate înaintea porturilor de intrare.

    Tabelul de mai jos oferă câteva exemple de instanțiere a unor porți în Verilog. Pentru primitivele predefinite numele instanței este opțional.

    SimbolCod
    OR Gateor(out, a, b, c); sau or o1(out, a, b, c);
    NOT Gatenot(out, in); sau `not my_not(out, in);`
    NAND Gatenand (z, x, y); sau nand n(z, x, y);

    Table: Exemple de instanțiere a primitivelor

    Wires​

    Un singur modul sau o singură primitivă nu poate îndeplini singură funcția cerută. Astfel, apare necesitatea interconectării modulelor sau a primitivelor. Specificarea semnalelor dintr-o diagramă se face prin wires, care se declară prin cuvântul cheie ''wire''.

    SimbolCod
    Gateswire y1, y2; xor(out, y1, y2); and(y1, in1, in2); nand(y2, in3, in4, in5);

    Table: Exemplu de formare a unei porti complexe din primitive

    În exemplul anterior y1 și y2 sunt semnale de câte 1 bit care leagă ieșirile porților and (y1) și nand (y2) la intrările porții xor.

    Pentru a declara semnale pe mai mulți biți se pot folosi vectori precum în declarațiile următoare: m reprezintă un semnal de 8 biți, iar n reprezintă un semnal de 5 biți. Bitul cel mai semnificativ (eng. most significant bit - MSB) este situat întotdeauna în stânga, iar bitul cel mai puțin semnificativ (eng. least significant bit - LSB) în dreapta.

    În mod implicit porturile care nu sunt declarate sunt considerate ca fiind de tip wire și având 1 bit (ex. in1, in2, … din codul de mai sus). Putem accesa individual biții dintr-un wire sau putem accesa un grup consecutiv de biți specificând intervalul (ex. m[0], m[3:1], m[7:2]).

    wire[7:0] m; _ 8 biti, MSB este bitul 7, LSB bitul 0 
    wire[0:4] n;  _ 5 biti, MSB este bitul 0, LSB bitul 4
    wire[7:0] a [9:0]; _ array multidimensional cu 10 elemente de 8 biti
    - + \ No newline at end of file diff --git "a/Laboratoare/1 Verilog Combina\310\233ional/Descriere structurala/index.html" "b/Laboratoare/1 Verilog Combina\310\233ional/Descriere structurala/index.html" index d564488..b10415a 100644 --- "a/Laboratoare/1 Verilog Combina\310\233ional/Descriere structurala/index.html" +++ "b/Laboratoare/1 Verilog Combina\310\233ional/Descriere structurala/index.html" @@ -4,13 +4,13 @@ Descriere structurala | Computer Architecture - +
    Skip to main content

    Descriere structurala

    - + \ No newline at end of file diff --git "a/Laboratoare/1 Verilog Combina\310\233ional/Limbaj Verilog/Teorie/index.html" "b/Laboratoare/1 Verilog Combina\310\233ional/Limbaj Verilog/Teorie/index.html" index 1ab8a08..6999a0c 100644 --- "a/Laboratoare/1 Verilog Combina\310\233ional/Limbaj Verilog/Teorie/index.html" +++ "b/Laboratoare/1 Verilog Combina\310\233ional/Limbaj Verilog/Teorie/index.html" @@ -4,14 +4,14 @@ Verilog | Computer Architecture - +
    Skip to main content

    Verilog

    În cadrul laboratorului de Arhitectura Calculatoarelor vom studia un limbaj de descriere a hardware-ului (eng. Hardware Description Language - HDL) numit Verilog. Îl vom folosi pe tot parcursul laboratorului pentru a implementa noțiuni legate de arhitectura calculatoarelor. Limbajele de descriere a hardware-ului sunt folosite în industrie pentru proiectarea și implementarea circuitelor digitale. Cele mai folosite limbaje de descriere a hardware-ului sunt Verilog și VHDL.

    Deși din punct de vedere sintactic se aseamănă foarte mult cu un limbaj de programare de uz general (C/C++/Java), trebuie ținut cont că instrucțiunile nu se execută secvențial, ca pe un procesor. Ținta unui cod scris în Verilog este implementarea sa pe un FPGA sau dezvoltarea unui ASIC (Application Specific Integrated Circuit).

    De ce Verilog?​

    Un limbaj de descriere hardware conține o serie de abstractizări sau moduri de a genera, prin intermediul codului, porți logice. În comparație cu a proiecta “de mână” circuitele integrate, tocmai aceste abstractizări sunt cele care au permis electronicii digitale să se dezvolte în ritm rapid, odată cu progresul tehnologiei de fabricație. Cu ajutorul lor putem descrie relativ ușor structuri complexe, divizându-le în componentele lor comune și de bază.

    Însă apare întrebarea naturală: Ce aș putea face cu un FPGA și nu aș putea face cu un procesor? Pe scurt, există trei răspunsuri:

    • Un FPGA poate fi reconfigurat într-un timp foarte scurt. Asta înseamnă că, dacă am greșit ceva în design-ul nostru, dacă dorim să-l modificăm sau să-l extindem, timpul și costul acestei acțiuni sunt foarte mici;
    • Un FPGA, prin construcția lui, oferă un grad extrem de ridicat de paralelism, lucru pe care codul scris pentru un procesor (deci cod secvențial) îl oferă într-o măsură mai redusă și mai greu de controlat;
    • Un FPGA este de preferat oricând se dorește interfațarea unui dispozitiv (un senzor, un dispozitiv de afișare, etc.) care are nevoie de timpi foarte stricți în protocolul de comunicatie (exemplu: așteaptă 15 nanosecunde înainte să schimbi linia de ceas, apoi activează linia de enable pentru 25 de nanosecunde, apoi pune datele pe linia de date și ține-le cel puțin 50 de nanosecunde, etc). Pe un procesor acest lucru este iarăși dificil de controlat, fiindcă majoritatea instrucțiunilor se execută într-un număr diferit de cicli de ceas.

    Întrucât au fost puse în discuție atât proiectarea prin porți logice a unui circuit cât și descrierea lui la un nivel mai abstract, putem clasifica alternative de descriere a unui circuit:

    • descrierea structurală - mai puțin folosită, ea reprezintă o implementare asemănătoare cu o schemă logică a unui circuit, folosind primitive și module pentru implementarea funcționalității
    • descrierea comportamentală - divizată în descriere la nivel de flux de date și descriere la nivel procedural, folosește construcții de nivel înalt, întâlnite și în alte limbaje de programare.

    Ce tipuri de circuite putem construi?​

    Circuitele logice combinaționale aplică funcții logice pe intrări pentru a obține ieșirile. Valorile de ieșire depind astfel doar de valorile curente de intrare, iar când starea unei intrări se schimbă, se reflectă imediat asupra ieșirii.

    Diagrama bloc pentru un circuit combinațional cu n intrări și m ieșiri

    Figure: Diagrama bloc pentru un circuit combinațional cu n intrări și m ieșiri

    Logica combinațională poate fi reprezentată prin:

    • diagrame structurale la nivel de porți logice,
    • tabele de adevăr,
    • expresii booleene (funcții logice).

    Spre deosebire de circuitele logice combinaționale, cele secvențiale (eng: sequential logic) nu mai depind exclusiv de valoarea curentă a intrărilor, ci și de stările anterioare ale circuitului. Logica secvențială poate fi de două tipuri: sincronă și asincronă.

    Schema bloc a unui circuit secvențial sincron

    Figure: Schema bloc a unui circuit secvențial sincron

    În primul caz, cel cu care vom lucra și la laborator, este folosit un semnal de ceas care comandă elementul/elementele de memorare, acestea schimbându-și starea doar la impulsurile de ceas. În al doilea caz, ieșirile se modifică atunci când se modifică și intrările, neexistând un semnal de ceas pentru elementele de memorare. Circuitele secvențiale asincrone sunt mai greu de proiectat, pot apărea probleme de sincronizare și sunt folosite mai rar. În continuare ne vom referi doar la circuitele secvențiale sincrone.

    - + \ No newline at end of file diff --git "a/Laboratoare/1 Verilog Combina\310\233ional/Limbaj Verilog/index.html" "b/Laboratoare/1 Verilog Combina\310\233ional/Limbaj Verilog/index.html" index d16ede0..ad02dd8 100644 --- "a/Laboratoare/1 Verilog Combina\310\233ional/Limbaj Verilog/index.html" +++ "b/Laboratoare/1 Verilog Combina\310\233ional/Limbaj Verilog/index.html" @@ -4,13 +4,13 @@ Limbaj Verilog | Computer Architecture - +
    Skip to main content

    Limbaj Verilog

    - + \ No newline at end of file diff --git "a/Laboratoare/1 Verilog Combina\310\233ional/index.html" "b/Laboratoare/1 Verilog Combina\310\233ional/index.html" index 89c54de..5b97cac 100644 --- "a/Laboratoare/1 Verilog Combina\310\233ional/index.html" +++ "b/Laboratoare/1 Verilog Combina\310\233ional/index.html" @@ -4,13 +4,13 @@ 1 Verilog Combinațional | Computer Architecture - +
    Skip to main content

    1 Verilog Combinațional

    - + \ No newline at end of file diff --git "a/Laboratoare/2 Verilog Combina\310\233ional/Operatori/Practic\304\203/index.html" "b/Laboratoare/2 Verilog Combina\310\233ional/Operatori/Practic\304\203/index.html" index f559f5c..c0f2c55 100644 --- "a/Laboratoare/2 Verilog Combina\310\233ional/Operatori/Practic\304\203/index.html" +++ "b/Laboratoare/2 Verilog Combina\310\233ional/Operatori/Practic\304\203/index.html" @@ -4,7 +4,7 @@ Practice: Operators | Computer Architecture - + @@ -12,7 +12,7 @@
    Skip to main content

    Practice: Operators

    1. Comparator pe 4 biți​

    Implementați și simulați un comparator pe 4 biți. Acesta are două intrări și 3 ieșiri (pentru mai mic, egal și mai mare).
    Hint: Unei variabile îi poate fi atribuită valoarea unei expresii logice.
    Hint: Considerând experiența exercițiului 2, există vreo posibilitate să parametrizați comparatorul?

    2. Multiplexor 4:1​

    1. Implementați și simulați un multiplexor 4:1. Urmăriți diagrama de semnale generată.
      Hint: Consultați laboratorul 0 pentru implementarea unui multiplexor 4:1.
      Hint: Respectați interfața cerută în scheletul de cod.
    2. Implementați multiplexorul folosind ecuația logică dedusă din tabelul de adevăr.
    3. Implementați multiplexorul folosind operatorul condițional ‘?’.
      Hint: Operatorul poate apărea de mai multe ori într-o expresie. ex: assign x = (a == 0) ? 1 : ( (a == 1) ? : 2 : 0 );

    Soluția se află în repo-ul materiei GitHub.

    - + \ No newline at end of file diff --git "a/Laboratoare/2 Verilog Combina\310\233ional/Operatori/Teorie/index.html" "b/Laboratoare/2 Verilog Combina\310\233ional/Operatori/Teorie/index.html" index 4ceaed7..46cbf9c 100644 --- "a/Laboratoare/2 Verilog Combina\310\233ional/Operatori/Teorie/index.html" +++ "b/Laboratoare/2 Verilog Combina\310\233ional/Operatori/Teorie/index.html" @@ -4,14 +4,14 @@ Descriere comportamentală | Computer Architecture - +
    Skip to main content

    Descriere comportamentală

    Laboratorul curent va prezenta elementele Verilog folosite pentru descrierea comportamentală. Aceasta poate descrie ce face circuitul și nu cum va fi acesta implementat. Mai mult, vom completa un modul funcțional cu un modul de testare, astfel încât să avem posibilitatea de a verifica implementarea pe care o concepem.

    Assign​

    Deși partiționarea circuitelor în cadrul unei arhitecturii duce la simplificarea implementării unui modul, implementarea acestuia la nivel de porți logice este rareori folosită, întrucât aceasta devine complicată și dificil de înțeles.

    Primul pas este reprezentat de ușurarea modalității de scriere a unei funcții logice. Pentru aceasta, Verilog oferă o instrucțiune numită atribuire continuă. Aceasta folosește cuvântul cheie ''assign'' și “atribuie” unei variabile de tip ''wire'', valoarea expresiei aflată în partea dreaptă a semnului egal. Atribuirea are loc la fiecare moment de timp, deci orice schimbare a valorii expresiei din partea dreaptă se va propaga imediat. În partea stângă a unei atribuiri continue se poate afla orice variabilă declarată de tip wire sau orice ieșire a modulului care nu are altă declarație (ex. reg). Expresiile din partea dreaptă pot fi formate din orice variabile sau porturi de intrare și de ieșire și orice operatori suportați de Verilog.

    Bazându-ne pe circuitul descris în figura de mai jos, acesta se poate scrie sub formă de atribuiri continue în următoarea formă:

    SimbolCod
    Gateswire y1, y2; xor(out, y1, y2); and(y1, in1, in2); nand(y2, in3, in4, in5);

    Exemplu atribuire continuă​

    module my_beautiful_module (
        output out,
        input  i1,i2,i3,i4,i5);        

              assign y1 = i1 & i2;
              assign y2 = ~(i3 & i4 & i5);

              assign out = y1 ^ y2;

    endmodule

    sau, mai concis:

    module my_beautiful_module (
        output out,
        input  i1,i2,i3,i4,i5);        

              assign out = (i1 & i2) ^  (~(i3 & i4 & i5));

    endmodule

    Se poate observa că o atribuire continuă este mult mai ușor de scris, de înțeles și de modificat decât o descriere echivalentă bazată pe instanțierea de primitive. Circuitul descris de o atribuire continuă poate fi însă relativ ușor sintetizat ca o serie de porți logice care implementează expresia dorită, unii operatori având o corespondență directă cu o poartă logică.

    Este o eroare să folosiți aceeași variabilă destinație pentru mai multe atribuiri continue. Ele vor încerca simultan să modifice variabila, lucru ce nu este posibil în hardware.

    Constante​

    Pentru specificarea valorilor întregi este folosită următoarea sintaxă:

    ''[size]'[radix] constant_value''

    • numerele conțin doar caracterele bazei lor și caracterul '_'
    • pentru a ușura citirea, se poate folosi caracterul '_' ca delimitator
    • caracterul '?' specifică impedanță mare (z)
    • caracterul 'x' specifică valoare necunoscută
    • se poate specifica dimensiunea numărului în biți dar și baza acestuia (b,B,d,D,h,H,o,O - binar, zecimal, hexa, octal) 
    8'b1;         //binar, pe 8 biti, echivalent cu 1 sau 8'b00000001
    8'b1010_0111; //binar, echivalent cu 167 sau 8'b10100111
    4'b10;        //binar, pe 4 biti, echivalent cu 2 sau 4'b0010 etc. 
    126;          //scriere in decimal
    16'habcd;     //scriere in hexazecimal

    Operatori​

    Descrierea comportamentală la nivelul fluxului de date, descrisă anterior, presupune în continuare cunoașterea schemei hardware la nivelul porților logice sau, măcar, expresia logică. Deși reprezintă o variantă mai simplă decât utilizarea primitivelor, nu este cea mai facilă.

    Pentru a ușura implementarea, Verilog pune la dispoziție mai multe tipuri de operatori. Unii dintre aceștia sunt cunoscuți din limbajele de programare precum C, C++, Java, și au aceeași funcționalitate. Alții sunt specifici limbajului Verilog și sunt folosiți în special pentru a descrie ușor circuite logice. Cu ajutorul acestora putem simplifica implementarea, apelând la construcții folosind limbajul de nivel înalt.

    Tabelul de mai jos conține operatorii suportați de Verilog, împreună cu nivelul lor de precedență.

    SimbolFuncțiePrecedență
    ! ~ + - (unari)Complement, Semn1
    **Ridicare la putere2
    * / %Înmulțire, Împărțire, Modulo3
    + - (binari)Adunare, Scădere4
    << >> <<< >>>Shiftare5
    < <= > >= == !=Relaționali6
    & ~& ^ ~^ ^~ | ~|Reducere7
    &&Logici8.1
    ||Logici8.2
    ?:Condițional9
    {,}Concatenare

    În continuare sunt prezentați operatorii mai neobișnuiți suportați de Verilog:

    • Operatorii de shiftare aritmetică; realizează shiftarea cu păstrarea bitului de semn, pentru variabilele declarate ca fiind cu semn.

      wire signed[7:0] a, x, y;
      assign x = a >>> 1;  // dacă bitul de semn al lui a este 0 bitul nou
                           //introdus este 0 
                           // dacă bitul de semn al lui a este 1 bitul nou
                           // introdus este 1
      assign y = a <<< 1;  // bitul nou introdus este tot timpul 0,
                           //asemănător cu operatorul <<

    • Operatorii de reducere; se aplică pe un semnal de mai mulți biți și realizează operația logică între toți biții semnalului

      wire[7:0] a; 
      wire x, y, z;
      assign x = &a;  // realizeaza AND între toți biții lui a 
      assign y = ~&a; // realizează NAND între toți biții lui a 
      assign z = ~^a; // realizeaza XNOR între toți biții lui a, 
                      // echivalent cu ^~

    • Operatorul de concatenare; realizează concatenarea a două sau mai multe semnale, într-un semnal de lățime mai mare.

      wire[3:0] a, b;
      wire[9:0] x; 

      // biții 9:6 din x vor fi egali cu biții 3:0 ai lui b
      // biții 5:4 din x vor fi egali cu 01
      // biții 3:2 din x vor fi egali cu biții 2:1 ai lui a 
      // biții 1:0 din x vor fi egali cu 00
      assign x = {b, 2'b01, a[2:1], 2'b00};
    - + \ No newline at end of file diff --git "a/Laboratoare/2 Verilog Combina\310\233ional/Operatori/index.html" "b/Laboratoare/2 Verilog Combina\310\233ional/Operatori/index.html" index 9787be5..b18fb3c 100644 --- "a/Laboratoare/2 Verilog Combina\310\233ional/Operatori/index.html" +++ "b/Laboratoare/2 Verilog Combina\310\233ional/Operatori/index.html" @@ -4,13 +4,13 @@ Operatori | Computer Architecture - +
    Skip to main content

    Operatori

    - + \ No newline at end of file diff --git "a/Laboratoare/2 Verilog Combina\310\233ional/Parametri/Practic\304\203/index.html" "b/Laboratoare/2 Verilog Combina\310\233ional/Parametri/Practic\304\203/index.html" index ed47a29..d65197e 100644 --- "a/Laboratoare/2 Verilog Combina\310\233ional/Parametri/Practic\304\203/index.html" +++ "b/Laboratoare/2 Verilog Combina\310\233ional/Parametri/Practic\304\203/index.html" @@ -4,7 +4,7 @@ Practice: Parameters | Computer Architecture - + @@ -12,7 +12,7 @@
    Skip to main content

    Practice: Parameters

    Sumator parametrizat pe n biți​

    Implementați și simulați un sumator parametrizat pe n biți, cu două intrări și o ieșire. Parametrizarea se va efectua asupra dimensiunii variabilelor.
    Hint: De câți parametri este nevoie? Observați dependența între dimensiunea variabilelor de intrare și cea de ieșire.
    Hint: Luând exemplul modulului de test implementat la exercițiul 1, instanțiați un sumator pe 6 biți și adăugați stimuli corespunzători pentru a-i testa întreaga plajă de valori.

    Soluția se află în repo-ul materiei GitHub.

    - + \ No newline at end of file diff --git "a/Laboratoare/2 Verilog Combina\310\233ional/Parametri/Teorie/index.html" "b/Laboratoare/2 Verilog Combina\310\233ional/Parametri/Teorie/index.html" index a42f000..e262112 100644 --- "a/Laboratoare/2 Verilog Combina\310\233ional/Parametri/Teorie/index.html" +++ "b/Laboratoare/2 Verilog Combina\310\233ional/Parametri/Teorie/index.html" @@ -4,13 +4,13 @@ Parametrizarea modulelor | Computer Architecture - +
    Skip to main content

    Parametrizarea modulelor

    Parameter​

    Cuvântul rezervat ''parameter'' este o construcție de limbaj în Verilog care permite unui modul să fie reutilizat cu specificații diferite. Spre exemplu, un sumator poate fi parametrizat să accepte o valoare pentru numărul de biți care poate să fie configurată diferit de la o simulare la alta. Comportamentul lor este similar cu cel al argumentelor unor funcții în alte limbaje de programare cunoscute. Folosind ''parameter'', este declarată o valoare constantă, prin urmare, este ilegală modificarea valorii acesteia în timpul simulării. De asemenea, este ilegal ca un alt tip de dată să aibă același nume ca unul dintre parametri.

    parameter MSB = 7;       // MSB este un parametru cu valoarea constantă 7
    parameter [7:0] number = 2’b11;    // o valoare de 2 biți este convertită
                                       // într-o valoare de 8 biți

    O variabilă de tip parametru este vizibilă local, în modulul ce a fost declarată.

    Construirea și instanțierea modulelor parametrizabile​

    Instanțierea modulelor a fost folosită și în laboratorul anterior pentru a invoca logica implementată într-un alt modul. În acel context, era necesar să cunoaștem dimensiunea semnalelor din interfață pentru a le potrivi cu variabilele conectate la instanță. În cazul în care un modul are dimensiunile porturilor parametrizate, acesta poate fi instanțiat cu valori particulare ale parametrilor (diferite de cele predefinite). Să considerăm drept exemplu modulul de mai jos:

    module my_beautiful_module (out, a, b);
        output [7:0] out;
        input [3:0] a;
        input [4:0] b;

        …// some logic
    endmodule

    Pentru a instanția acest modul, vom avea nevoie de 3 variabile de 8, 4, respectiv 5 fire pe care le vom conecta astfel:

    My_beautiful_module inst1(out, a, b);

    Pe de altă parte, având modulul:

    module my_beautiful_parameterized_module(out, a, b);
        parameter a_width = 4;
        parameter b_width = 5;
        parameter out_width = 8;

        output [out_width-1:0] out;
        input [a_width-1:0] a;
        input [b_width-1:0] b;

        …// some logic
    endmodule

    Îi putem utiliza logica fără a depinde de o dimensiune predefinită a semnalelor din interfață

    wire [4:0] out1;
    wire [4:0] out2;
    wire [2:0] a;
    wire [1:0] b;

    my_beautiful_parameterized_module #(.a_width(3),
                                        .b_width(2),
                                        .out_width(5)) inst2(out, a, b);

    // Sau, menținându-se ordinea parametrilor, doar prin specificarea noilor dimensiuni:

    my_beautiful_parameterized_module #(3, 2, 5) inst3(out, a, b);

    Macro: `define​

    Un macro este un nume căruia i se poate asocia o valoare înainte de compilarea codului. Macro-urile sunt utile pe post de aliasuri, fără a utiliza resursele compilatorului. Acestea nu sunt variabile, prin urmare nu pot fi atribuite valori unui macro în timpul simulării. Majoritatea limbajelor de programare, inclusiv Verilog suportă definirea de macrouri.

    În Verilog, un macro este specificat cu ajutorul directivei de compilator `define. Aceasta înlocuiește textul definit cu o valoare specifică. Un nume de tip define este un macro global, însemnând că dacă este declarat într-un modul, va rămâne declarat și la ieșirea din modul. După ce macroul este declarat, poate fi apelat în cod cu ajutorul caracterului (back-tic). Indiferent dacă sunt declarate în interiorul sau în afara unui modul, compilatorul le tratează la fel.

    `define MY_NUMBER 5
    `define MY_STRING “Hello world!”
    `define ADD2PLUS2 2 + 2
    - + \ No newline at end of file diff --git "a/Laboratoare/2 Verilog Combina\310\233ional/Parametri/index.html" "b/Laboratoare/2 Verilog Combina\310\233ional/Parametri/index.html" index 35f163f..bbf35fc 100644 --- "a/Laboratoare/2 Verilog Combina\310\233ional/Parametri/index.html" +++ "b/Laboratoare/2 Verilog Combina\310\233ional/Parametri/index.html" @@ -4,13 +4,13 @@ Parametri | Computer Architecture - +
    Skip to main content

    Parametri

    - + \ No newline at end of file diff --git "a/Laboratoare/2 Verilog Combina\310\233ional/Testare/Practic\304\203/index.html" "b/Laboratoare/2 Verilog Combina\310\233ional/Testare/Practic\304\203/index.html" index d1c3f26..4aad010 100644 --- "a/Laboratoare/2 Verilog Combina\310\233ional/Testare/Practic\304\203/index.html" +++ "b/Laboratoare/2 Verilog Combina\310\233ional/Testare/Practic\304\203/index.html" @@ -4,7 +4,7 @@ Practice: Testing simulation | Computer Architecture - + @@ -16,7 +16,7 @@ Hint: Testați atât situații obișnuite de adunare, cât și situații speciale (ex. carry = 1).
    Hint: Consultați forma de undă pentru a determina corectitudinea implementării. Verificați corectitudinea sumatorului vizualizând semnalele în baza 10.

  • Analizând implementarea din Laboratorul 1 și varianta curentă, analizați cele două tipuri de implementări.
    Hint: Comparați puncte forte, puncte slabe pentru fiecare din cele două variante.

    • Soluția se află în repo-ul materiei GitHub.

    - + \ No newline at end of file diff --git "a/Laboratoare/2 Verilog Combina\310\233ional/Testare/Teorie/index.html" "b/Laboratoare/2 Verilog Combina\310\233ional/Testare/Teorie/index.html" index c581ef7..4514737 100644 --- "a/Laboratoare/2 Verilog Combina\310\233ional/Testare/Teorie/index.html" +++ "b/Laboratoare/2 Verilog Combina\310\233ional/Testare/Teorie/index.html" @@ -4,13 +4,13 @@ Testare | Computer Architecture - +
    Skip to main content

    Testare

    Pentru testarea unui modul folosind simulatorul se creează module speciale de test, în care, printre altele, se vor atribui valori intrărilor. Simularea permite detecția rapidă a erorilor de implementare și corectarea acestora.

    Pentru a crea un modul de test și a-l simula puteți urma tutorialul de simulare aici, iar această secțiune va prezenta câteva din construcțiile de limbaj pe care le puteți folosi într-un astfel de modul.

    Diagrama testare circuit

    Figure: Diagrama testare circuit

    Blocul initial​

    Blocurile initial descriu un comportament executat o singură dată la începerea/activarea simulării și sunt folosite pentru inițializări și în module de test. Instrucțiunile sale trebuie încadrate între cuvintele cheie begin și end și sunt executate secvențial.

    initial begin 
        a = 0; 
        b = 1; 
        #10; _ delay 10 unități de timp de simulare 
        a = 1; 
        b = 0; 
    end

    Blocurile initial nu sunt sintetizabile, fiind folosite doar în simulări.

    Sincronizarea prin întârziere​

    Folosind operatorul # se poate specifica o durată de timp între apariția instrucțiunii și momentul executării acesteia. Aceasta este utilă pentru a separa temporal diversele atribuiri ale intrărilor. Durata de timp este reprezentată prin unități de timp de simulare. De exemplu, dacă simularea folosește un timescale în nanosecunde, #n va reprezenta n nanosecunde.

    Afișare​

    Atât în modulele de test cât și în modulele testate se pot folosi construcții pentru afișare în interiorul blocurilor initial și always. Una dintre aceste instrucțiuni este display:

    $display(arguments);

    Argumentele acestei comenzi sunt similare cu cele ale funcției printf din C, ca în exemplul de mai jos, iar specificația completă o puteți găsi aici. $display adaugă o linie nouă, iar dacă nu se dorește acest lucru se poate folosi comanda $write. 

    a = 1; b = 4;

    $display("suma=%d", a+b);
    - + \ No newline at end of file diff --git "a/Laboratoare/2 Verilog Combina\310\233ional/Testare/index.html" "b/Laboratoare/2 Verilog Combina\310\233ional/Testare/index.html" index 962c3ac..f1eaf43 100644 --- "a/Laboratoare/2 Verilog Combina\310\233ional/Testare/index.html" +++ "b/Laboratoare/2 Verilog Combina\310\233ional/Testare/index.html" @@ -4,13 +4,13 @@ Testare | Computer Architecture - +
    Skip to main content

    Testare

    - + \ No newline at end of file diff --git "a/Laboratoare/2 Verilog Combina\310\233ional/index.html" "b/Laboratoare/2 Verilog Combina\310\233ional/index.html" index 3b8d324..fe37f8a 100644 --- "a/Laboratoare/2 Verilog Combina\310\233ional/index.html" +++ "b/Laboratoare/2 Verilog Combina\310\233ional/index.html" @@ -4,13 +4,13 @@ 2 Verilog Combinațional | Computer Architecture - +
    Skip to main content

    2 Verilog Combinațional

    - + \ No newline at end of file diff --git "a/Laboratoare/3 Verilog Combina\310\233ional/Descriere Comportamentala/Practic\304\203/index.html" "b/Laboratoare/3 Verilog Combina\310\233ional/Descriere Comportamentala/Practic\304\203/index.html" index 27b7c95..a10ab00 100644 --- "a/Laboratoare/3 Verilog Combina\310\233ional/Descriere Comportamentala/Practic\304\203/index.html" +++ "b/Laboratoare/3 Verilog Combina\310\233ional/Descriere Comportamentala/Practic\304\203/index.html" @@ -4,13 +4,13 @@ Exerciții | Computer Architecture - +
    Skip to main content

    Exerciții

    Seven-segment display​

    Acest tip de dispozitiv de afișare este alcătuit, așa cum vă puteți da seama și din numele acestuia, din 7 segmente controlabile individual. Așadar, putem aprinde (1 logic) sau stinge (0 logic) fiecare segment din componența acestuia.

    Reprezentarea numerelor în format hexazecimal considerând un afișaj cu 7 segmente

    Figure: Reprezentarea numerelor în format hexazecimal considerând un afișaj cu 7 segmente

    De exemplu, dacă dorim să afișăm cifra 6, ieșirea noastră va avea valoarea ''7’b111_1101''.

    Pentru mai multe detalii asupra acestui tip de modul, consultați pagina de Wiki.

    Soluția se află în repo-ul materiei GitHub.

    1. Implementați și simulați un multiplicator pe 4 biți fără a folosi operatorul * (înmulțire).
      • Hint: Folosiți convenția Verilog pentru interfața modulului. Câți biți are ieșirea?
      • Hint: Înmulțiți pe hârtie, în baza 2, numerele 1001 și 1011. Transpuneți în limbajul Verilog algoritmul folosit.
    2. Implementați și simulați un modul de afișaj cu 7 segmente pentru numere în baza 10.
      • Hint: Există o ieșire validă pentru fiecare intrare? Nu uitați de cazul ''default''.
      • Hint: Se vor testa doar cifrele de la 0 la 9.
    3. Implementați o unitate aritmetico-logică simplă (UAL), pe 4 biți, cu 2 operații: adunare și înmulțire. Folosiți o intrare de selecție de 1 bit pentru a alege între cele două operații astfel: 0 - adunare, 1 - înmulțire.
      • Hint: Câți biți au ieșirea sumatorului și a multiplicatorului? Dar a UAL-ului?
      • Hint: Pentru selecția dintre ieșirea sumatorului și cea a multiplicatorului se poate folosi atribuirea continuă sau se poate implementa un modul multiplexor 2:1
      • Pentru o utilizare mai generală, implementați un UAL cu operatori cu dimensiune variabilă.
        • Hint: Pentru a-l implementa, este necesară implementarea unui multiplicator parametrizat - atenție la dimensiunea semnalelor!
    - + \ No newline at end of file diff --git "a/Laboratoare/3 Verilog Combina\310\233ional/Descriere Comportamentala/Teorie/index.html" "b/Laboratoare/3 Verilog Combina\310\233ional/Descriere Comportamentala/Teorie/index.html" index 754456c..4307a19 100644 --- "a/Laboratoare/3 Verilog Combina\310\233ional/Descriere Comportamentala/Teorie/index.html" +++ "b/Laboratoare/3 Verilog Combina\310\233ional/Descriere Comportamentala/Teorie/index.html" @@ -4,13 +4,13 @@ Descrierea comportamentală | Computer Architecture - +
    Skip to main content

    Descrierea comportamentală

    În laboratoarele anterioare am studiat descrierea structurală, folosind primitive, precum și descrierea comportamentală, folosind atribuiri continue. Am remarcat faptul că generalizarea modulelor folosind parametri conduce la o capacitate de reutilizare mai mare, cu schimbări minime. Cu toate acestea, soluțiile prezentate nu sunt pretabile funcțiilor complexe, întrucât ele devin complicat de implementat sau de urmărit, în momentul când este găsit un bug în cod.

    In continuare vom trece prin elementele Verilog folosite pentru descrierea comportamentală la nivel procedural, ce se vor axa în continuare pe conceptul de “ce face circuitul”. Se folosesc construcții de nivel înalt, similare altor limbaje de programare întâlnite până în prezent, prin care putem descrie mai facil algoritmul care calculează ieșirile circuitului.

    Tipul reg​

    În primele laboratoare a fost prezentat tipul wire pentru reprezentarea semnalelor din interiorul modulelor. Porturile unui modul erau wires, la fel și semnalele de legătură dintre instanțele primitivelor și porților. Deoarece acestea realizează conexiuni, nu au o stare și nu li se pot atribui valori. Pentru a putea reține stări/valori și a face atribuiri avem nevoie de tipul reg.

    Declararea variabilelor de tip reg se poate face într-un mod similar variabilelor de tip wire, cum este exemplificat și mai jos:

    Exemplu declarare variabilă de tip reg​

    reg x;
    reg[7:0] m; 
    reg[0:4] n;
    reg[7:0] a [3:0]; // array multidimensional cu 4 elemente de 8 biti

    Declararea unei variabile de tip reg (deci o variabilă de tip registru în Verilog) nu implică sinteza unui registru hardware!

    Construcții de control​

    În afară de folosirea atribuirilor continue, circuitele pot fi descrise comportamental și prin blocuri always. În interiorul acestora se pot folosi construcții de limbaj similare celor din limbajele procedurale.

    Construcțiile de repetiție sunt sintetizabile doar dacă ele au un număr fix de iterații. Trebuie acordată o deosebită atenție în momentul în care se implementează structuri repetitive utilizând while sau repeat, acestea fiind mult mai susceptibile la greșeli de implementare care vor genera, în final, un cod simulabil, dar nesintetizabil.

    Cod VerilogCod C
    if (sig == 0) begin a = 2; end else if (sig == 1 ) begin a = 1; end else begin a = 0; endif (sig == 0) { a = 2; } else if (sig == 1) { a = 1; } else { a = 0; }
    case (sig) 'b0: a = 2; 'b1: a = 1; default: a = 0; endcaseswitch (sig) { case 0: a = 2; break; case 1: a = 1; break; default: a = 0; }
    for (i = 0; i < 10; i = i + 1) begin a = a / 2; endfor (i = 0; i < 10; i = i + 1) { a = a / 2; }
    i = 0; while (i < 10) begin a = a / 2; i = i + 1; endi = 0; while (i < 10) { a = a / 2; i = i + 1; }
    repeat (10) begin a = a / 2; end

    Blocul always@​

    Blocurile always descriu un comportament ciclic, codul acestora fiind executat în continuu. Prezența operatorului @ face ca blocul să se “execute” doar la apariția unor evenimente. Evenimentele sunt reprezentate de modificarea unuia sau mai multor semnale.

    În cadrul acestui laborator ne axăm doar pe descrierea circuitelor combinaționale și vom folosi doar blocuri ''always @()'', unde () se numește sensitivity list. Folosirea wildcard-ului * implică “execuția” blocului always la orice eveniment de modificare a oricărui semnal folosit în cadrul blocului.

    Instrucțiunile din blocul always sunt încadrate între cuvintele cheie ''begin'' și ''end'' și sunt “executate” secvențial atunci când blocul este activat. 

    always @(*) begin
       b = 0;     // registrul b este inițializat cu 0 la orice
                  // modificare a unui semnal
       c = b ^ a; // registrul c va primi valoarea expresiei din dreapta
                  // la orice modificare a unui semnal (nu doar a sau b)
    end

    În locul wildcard-ului *, sensitivity list-ul poate conține o listă de semnale la modificarea cărora blocul always să fie activat. Acestea se declară prin numele lor, folosind or sau , pentru a le separa.

    Este foarte important ca lista de semnale dată unui bloc always@ să fie completă, altfel nu toate combinațiile de intrări sunt acoperite și unele variabile pot rămâne neatribuite corespunzător. Pentru a evita astfel de erori se recomandă folosirea wildcard-ului *.

    Exemplu declarare listă de senzitivitate​

    always @(a or b or c) // sintaxa Verilog-1995
    always @(a, b, c)     // sintaxa Verilog-2001, 2005
    always @(a, b or c)   // permis dar nerecomandat, îngreunează
                          // lizibilitatea codului
    always @(*)           // toate semnalele din modul (intrări +
                          // wires declarate în modul)

    În modulul următor care implementează o poartă xor, ieșirea out se va schimba doar când semnalul a se schimbă, ceea ce duce la un comportament incorect care nu ia în considerare și schimbarea lui b. În plus, modulul generat nu va fi unul combinațional, deoarece este nevoie de memorie pentru a menține starea ieșirii atunci când b se modifică.

    module my_xor(output reg out, input a, input b);
        always @(a) begin
            out = a ^ b;
        end
    endmodule

    Nu se pot instanția primitive și module în interiorul blocurilor always și initial.

    În cadrul blocurilor initial și always atribuirile pot fi de două feluri, cu semantici diferite:

    • Atribuiri blocante: sunt folosite pentru descrierea logicii combinaționale (porți logice). Atribuirile blocante sunt interpretate ca executându-se secvențial, semantica fiind identică cu cea din limbajele de programare procedurale.
    • Atribuiri non-blocante: sunt folosite pentru descrierea logicii secvențiale (ne vom întâlni cu ele în laboratorul următor).

    În Verilog putem declara variabile de tipul reg și wire pentru a crea circuite combinaționale. Atunci când se fac atribuirile există totuși următoarele restricții:

    • Pe o variabilă de tip wire nu putem face decât atribuiri continue (assign). Acestea trebuie să fie în exteriorul blocurilor always sau initial. Valoarea atribuită poate fi o constantă, o expresie, valoarea unui fir sau a unui registru.
    • Pe o variabilă de tip reg putem face doar atribuiri blocante/non-blocante. Acestea trebuie să fie în interiorul unui bloc initial sau always. Valoarea atribuită poate fi o constantă, o expresie, valoarea unui fir sau a unui registru.

    Exemplu sumator descris comportamental, folosind always@​

    module my_module(
        output reg[4:0] o, // o trebuie sa fie reg pentru a o putea atribui
                           // în blocul always
        input[3:0] a, b);

        reg[2:0] i;        // poate fi maxim 7; noi avem nevoie de maxim 4
        reg c;             // ținem minte transportul

        always @(*) begin
            i = 0; // la orice modificare a intrărilor, i va fi inițial 0
            c = 0; // transportul initial este 0
        
            // toți biții lui o sunt recalculati la modificarea intrărilor
            for (i = 0; i < 4; i = i + 1) begin
                {c, o[i]} = a[i] + b[i] + c;
            end
            o[4] = c;
        end
    endmodule

    Pentru ca un bloc always să fie sintetizat într-un circuit combinațional este necesar ca orice “execuție” a blocului să atribuie cel puțin o valoare pentru fiecare ieșire a modulului.

    Bineînțeles, acea valoare nu poate fi calculată pe baza ieșirilor sau valorilor anterioare ale variabilelor din interiorul modulului. Asta ar însemna că este necesară o memorie pentru a menține acele valori, transformând circuitul într-unul secvențial.

    Nu este recomandată declararea variabilelor de tip reg în interiorul blocurilor de tip always sau initial. În Verilog ea este totuși posibilă, dacă blocul respectiv are un tag asociat. Variabila astfel declarată va avea vizibilitate doar în interiorul blocului.

    Exemplu declarare variabilă de tip reg în interiorul blocului always​

    always @(*) begin :my_tag
        reg x;
        x = in1 ^ in2;
    end
    - + \ No newline at end of file diff --git "a/Laboratoare/3 Verilog Combina\310\233ional/Descriere Comportamentala/index.html" "b/Laboratoare/3 Verilog Combina\310\233ional/Descriere Comportamentala/index.html" index 1f75082..484092d 100644 --- "a/Laboratoare/3 Verilog Combina\310\233ional/Descriere Comportamentala/index.html" +++ "b/Laboratoare/3 Verilog Combina\310\233ional/Descriere Comportamentala/index.html" @@ -4,13 +4,13 @@ Descriere Comportamentala | Computer Architecture - +
    Skip to main content

    Descriere Comportamentala

    - + \ No newline at end of file diff --git "a/Laboratoare/3 Verilog Combina\310\233ional/index.html" "b/Laboratoare/3 Verilog Combina\310\233ional/index.html" index bc99e8e..e19bd92 100644 --- "a/Laboratoare/3 Verilog Combina\310\233ional/index.html" +++ "b/Laboratoare/3 Verilog Combina\310\233ional/index.html" @@ -4,13 +4,13 @@ 3 Verilog Combinațional | Computer Architecture - +
    Skip to main content

    3 Verilog Combinațional

    - + \ No newline at end of file diff --git "a/Laboratoare/4 Verilog Secven\310\233ial/Always-Edge/Teorie/index.html" "b/Laboratoare/4 Verilog Secven\310\233ial/Always-Edge/Teorie/index.html" index 5294cee..5cb64c5 100644 --- "a/Laboratoare/4 Verilog Secven\310\233ial/Always-Edge/Teorie/index.html" +++ "b/Laboratoare/4 Verilog Secven\310\233ial/Always-Edge/Teorie/index.html" @@ -4,13 +4,13 @@ Blocul always@ edge-triggered | Computer Architecture - +
    Skip to main content

    Blocul always@ edge-triggered

    În afară de circuitele care depind doar schimbarea nivelului semnalului, există și circuite al căror comportament depinde de tranzițiile semnalului (activ pe front crescător sau front descrescător). Starea bistabililor, de exemplu, se modifică pe frontul crescător sau descrescător al unui semnal de ceas. În cazul acesta, blocul ''always@'' trebuie să se execute la detecția unui astfel de front (eng. edge-triggered). Pentru a modela un astfel de comportament Verilog oferă cuvântul cheie posedge ce poate fi alăturat numelui semnalului unui semnal din lista de senzitivități pentru a indica activarea blocului ''always'' la un front al semnalului. De exemplu blocul "always @(posedge clk)" se activează pe frontul crescător al semnalului clk.

    Sensitivity list​

    Cuvintele cheie posedge (pentru front crescător) și negedge (pentru front descrescător) indică activarea blocului always@ edge-triggered la schimbarea frontului semnalului.

    Exemplu sensitivity list​

    always @(posedge sig)   // frontul crescător al semnalului 'sig'
    always @(negedge sig)   // frontul descrescător al semnalului 'sig'
    always @(posedge sig1, posedge sig2)    // frontul crescator al 
    // semnalului 'sig1' sau frontul crescător al semnalului 'sig2'
    always @(posedge sig1, negedge sig2)    // frontul crescător al
    // semnalului 'sig1' sau frontul descrescător al semnalului 'sig2'

    Atribuiri non-blocante​

    În blocurile ''always@'' din laboratoarele precedente au fost folosite atribuirile ce utilizează operatorul "=", numite atribuiri blocante, deoarece se execută secvențial, ca în limbajele de programare procedurale (C, Java etc). Verilog oferă și un alt tip de atribuiri, care sunt executate toate în același timp, în paralel, indiferent de ordinea lor în bloc. Pentru a descrie un astfel de comportament se folosește operatorul "<=", iar atribuirile se numesc atribuiri non-blocante. Acest nou tip de atribuire modelează concurența care poate fi întâlnită în hardware la transferarea datelor între registre.

    Variabilele cărora li se atribuie o valoare trebuie să fie de tip registru (reg, integer) atât în cazul blocant cât și în cel non-blocant. Simulatorul evaluează întâi partea dreaptă a atribuirilor și apoi atribuie valorile către partea stângă. Acest lucru face ca ordinea atribuirilor non-blocante să nu conteze, deoarece rezultatul lor va depinde de ce valori aveau variabilele din partea dreaptă înainte de execuție.

    Exemplu atribuiri non-blocante ==​

    always @(posedge sig) // executat pe frontul crescător al semnalului sig
    begin  
        a <= b;
        b <= a;     // se interschimba valoarea lui a cu cea a lui b
        c <= d;     // toate trei atribuirile au loc în același timp
    end

    În cadrul blocurilor always care modelează logică combinațională se folosesc atribuiri blocante ("="), iar în blocurile care modelează logică secvențială se folosesc atribuiri non-blocante ("<=")

    Bistabilul D​

    Exemplele următoare reprezintă implementarea unui bistabil D, prezentat în laboratorul 0, care menține valoarea de intrare ("D") între două fronturi crescătoare ale semnalului de ceas ("clk"). Circuitului prezentat în laboratorul 0 i s-a adăugat și un semnal de reset ("rst_n"). Numele semnalului de reset se termină cu "_n", în mod convențional, pentru a sugera că acesta este activ pe negedge.

    În exemplul de mai jos, semnalul de reset este verificat sincron, atribuirile făcute ieșirii Q fiind non-blocante. Observați că operația de reset este condiționată de valoarea "0" a semnalului "rst_n".

    Bistabilul D - reset verificat sincron​

    module D_flip_flop(output reg Q, input D, clk, rst_n);
     
    always @(posedge clk) begin
        if(!rst_n)
          Q <= 0;
        else
          Q <= D;
    end
     
    endmodule

    Verificarea resetului se poate realiza și în mod asincron.

    Informații adiționale despre always asincron​

    În cel de-al doilea exemplu, semnalul este verificat asincron. Modulul este sintetizabil și are un comportament asemănător cu modulul asincron din al treilea exemplu. Pentru a fi sintetizabil este necesar ca toate atribuirile asupra registrului Q să fie realizate în același bloc always, iar blocul always să fie activat pe frontul crescător al semnalului clk sau pe frontul crescător al semnalului !rst_n.

    Bistabilul D - reset verificat asincron​

    module D_flip_flop(output reg Q, input D, clk, rst_n);
     
    always @(posedge clk or negedge rst_n) begin
        if(!rst_n)
          Q <= 0;
        else
          Q <= D;
    end
     
    endmodule

    Un modul este nesintetizabil dacă acesta conține atribuiri asupra aceluiași registru în mai mult de un bloc always.

    În cel de-al treilea exemplu, este prezentat cazul în care semnalul de reset este verificat asincron, iar atribuirile făcute ieșirii Q sunt blocante în cazul în care semnalul "!rst_n" devine 1 logic sau non-blocante pe frontul crescător al semnalului "clk". În acest caz, se obține un modul nesintetizabil.

    Bistabilul D - reset verificat sincron (modul nesintetizabil)​

    always @(posedge clk) begin
        if(rst_n)
           Q <= D;
    end

    always @(*) begin
        if(!rst_n)
           Q <= 0;
    end
     
    endmodule
    - + \ No newline at end of file diff --git "a/Laboratoare/4 Verilog Secven\310\233ial/Always-Edge/index.html" "b/Laboratoare/4 Verilog Secven\310\233ial/Always-Edge/index.html" index 7c5a9ec..b8cc207 100644 --- "a/Laboratoare/4 Verilog Secven\310\233ial/Always-Edge/index.html" +++ "b/Laboratoare/4 Verilog Secven\310\233ial/Always-Edge/index.html" @@ -4,13 +4,13 @@ Always-Edge | Computer Architecture - +
    Skip to main content

    Always-Edge

    📄️ Teorie

    În afară de circuitele care depind doar schimbarea nivelului semnalului, există și circuite al căror comportament depinde de tranzițiile semnalului (activ pe front crescător sau front descrescător). Starea bistabililor, de exemplu, se modifică pe frontul crescător sau descrescător al unui semnal de ceas. În cazul acesta, blocul ''always@'' trebuie să se execute la detecția unui astfel de front (eng. edge-triggered). Pentru a modela un astfel de comportament Verilog oferă cuvântul cheie posedge ce poate fi alăturat numelui semnalului unui semnal din lista de senzitivități pentru a indica activarea blocului ''always'' la un front al semnalului. De exemplu blocul "always @(posedge clk)" se activează pe frontul crescător al semnalului clk.

    - + \ No newline at end of file diff --git "a/Laboratoare/4 Verilog Secven\310\233ial/Debouncer/Practic\304\203/index.html" "b/Laboratoare/4 Verilog Secven\310\233ial/Debouncer/Practic\304\203/index.html" index e2638ab..1357e4b 100644 --- "a/Laboratoare/4 Verilog Secven\310\233ial/Debouncer/Practic\304\203/index.html" +++ "b/Laboratoare/4 Verilog Secven\310\233ial/Debouncer/Practic\304\203/index.html" @@ -4,13 +4,13 @@ Practice: Debouncer | Computer Architecture - +
    Skip to main content

    Practice: Debouncer

    Soluția se află în repo-ul materiei GitHub.

    • Se dorește proiectarea unui automat finit capabil să recunoască secvențe de tip "ba". Automatul primește la intrare în mod continuu caractere codificate printr-un semnal de un bit (caracterele posibile sunt "a" și "b"). Ieșirea automatului va consta dintr-un semnal care va fi activat (valoarea 1) atunci când la intrare am avut prezent un șir care se potrivește cu tiparul de căutare.
      • Implementați automatul în Verilog.
        • Hint: Realizați pe hârtie schema automatului de stări, pentru a o folosi ulterior ca referință.
      • Simulați automatul folosind modulul de test din scheletul de cod. Eliminați semnalele nerelevante (is și count) din diagrama de semnale. Adăugați starea automatului și starea următoare a automatului la diagrama de semnale.
        • Hint: Semnalele pot fi eliminate din diagrama de semnale cu click dreapta->Delete pe semnalul care se dorește a fi eliminat.
        • Hint: Semnale noi pot fi adăugate la diagrama de semnale prin drag-and-drop din fereastra Simulation Objects for ..., care conține toate semnalele modulului selectat în fereastra Instance and Process Name.
        • Hint: Simularea trebuie repornită prin Simulation->Restart urmat de Simulation->Run pentru a vedea comportamentul semnalelor adăugate.
      • Urmăriți diagrama de semnale și codul automatului și explicați comportamentul. Urmăriți și explicați funcționarea modulului de test.
    • Se dorește realizarea unei treceri de pietoni semaforizate. Duratele de timp pentru cele 2 culori vor fi: roșu - 60 sec, verde - 30 sec.
      • Implementați și simulați în Verilog automatul necesar. Ce rol are modulul trecere din fișierul trecere.v?
      • Explicați codul numărătorului din fișierul counter.v.
        • Hint: Urmăriți comportarea acestuia pe diagrama de semnale.
    - + \ No newline at end of file diff --git "a/Laboratoare/4 Verilog Secven\310\233ial/Debouncer/Teorie/index.html" "b/Laboratoare/4 Verilog Secven\310\233ial/Debouncer/Teorie/index.html" index 2423426..a54a96a 100644 --- "a/Laboratoare/4 Verilog Secven\310\233ial/Debouncer/Teorie/index.html" +++ "b/Laboratoare/4 Verilog Secven\310\233ial/Debouncer/Teorie/index.html" @@ -4,14 +4,14 @@ Debouncer | Computer Architecture - +
    Skip to main content

    Debouncer

    Elementele de memorare (stare) ale circuitului se modelează printr-un bloc activ pe frontului semnalului de ceas. În blocul combinațional trebuie tratate toate stările posibile ale automatului, semnalele de ieșire și tranzițiile din aceste stări.

    module fsm(output reg out, input in, clk, reset_n);
    reg [2:0] state, next_state;

    // partea secvențială
    always @(posedge clk) begin
        if (reset_n == 0) state <= 0;
        else state <= next_state;
    end

    // partea combinationala
    always @(*) begin
        out = 0;
        case (state)
            0:   if (in == 0) begin 
                     next_state = 1;
                     out = 1;
                 end
                 else next_state = 2;
            1:   if (in == 0) begin
                     next_state = 3;
                     out = 1;
                 end
                 else next_state = 4;         
        ...
        endcase
    end
    endmodule
    Nu combinați blocurile secvențiale cu cele combinaționale (e.g. "always @(posedge clk, state, in)") deoarece majoritatea utilitarelor nu vor sintetiza corect un astfel de circuit.

    Expresii regulate​

    Expresiile Regulate sunt secvențe de caractere ce definesc un tipar de căutare, folosite în multe cazuri pentru identificarea șirurilor sau sub-șirurilor de caractere ce se potrivesc cu expresia. Cea mai simplă metodă de vizualizare a unei expresii regulate este prin intermediul Automatelor Finite de stări.

    Pentru a descrie un tipar care conține un sub-șir între zero și nelimitate ori, este utilizat cuantificatorul "*", iar pentru a descrie un tipar care conține un sub-șir între una și nelimitate ori, este utilizat cuantificatorul "+".

    Parantezele "(" ")" sunt folosite pentru a delimita grupuri de caractere. Dacă acestea nu sunt specificate, cuantificatorul va avea efect asupra caracterului anterior.

    Exemple:​

    a(bc)*  -  se va potrivi cu șirurile de caractere 'a', 'abc', 'abcbc', 'abcbcbc' etc.
    (ab)+c  -  se va potrivi cu șirurile de caractere 'abc', 'ababc', 'abababc' etc.
    ab+a    -  se va potrivi cu șirurile de caractere 'aba', 'abba', 'abbba' etc.
    Nu confundați operatorii "*" și "+" cu înmulțire și adunare. În contextul expresiilor regulate, aceștia sunt folosiți pentru a descrie tipare de căutare și **NU** sunt folosiți pentru a scrie cod Verilog.

    Debouncing​

    Atunci când un buton este apăsat sau un switch este comutat, două părți metalice intră în contact pentru a permite curentului să treacă. Cu toate acestea, ele nu se conectează instantaneu, ci se conectează și deconectează de câteva ori înainte de realizarea conexiunii propriu-zise. Același lucru se întâmplă și în momentul eliberării unui buton (când acesta nu mai este apăsat). Acest fenomen poate conduce la comutări false sau modificări multiple nedorite asupra semnalului și este denumit bouncing.

    Prin urmare, se poate spune că fenomenul de "bouncing" nu este un comportament ideal pentru niciun switch care execută mai multe tranziții ale unei singure intrări. Aceasta nu este o problemă majoră când avem de-a face cu circuite de putere, dar poate cauza probleme atunci când avem de-a face cu circuitele logice sau digitale. Așadar, pentru a elimina oscilațiile din semnal cauzate de acest fenomen se folosește principiul de Switch Debouncing.

    - + \ No newline at end of file diff --git "a/Laboratoare/4 Verilog Secven\310\233ial/Debouncer/index.html" "b/Laboratoare/4 Verilog Secven\310\233ial/Debouncer/index.html" index f492f2a..7204516 100644 --- "a/Laboratoare/4 Verilog Secven\310\233ial/Debouncer/index.html" +++ "b/Laboratoare/4 Verilog Secven\310\233ial/Debouncer/index.html" @@ -4,13 +4,13 @@ Debouncer | Computer Architecture - +
    Skip to main content

    Debouncer

    - + \ No newline at end of file diff --git "a/Laboratoare/4 Verilog Secven\310\233ial/index.html" "b/Laboratoare/4 Verilog Secven\310\233ial/index.html" index 0c357e6..6f3efc1 100644 --- "a/Laboratoare/4 Verilog Secven\310\233ial/index.html" +++ "b/Laboratoare/4 Verilog Secven\310\233ial/index.html" @@ -4,13 +4,13 @@ 4 Verilog Secvențial | Computer Architecture - +
    Skip to main content

    4 Verilog Secvențial

    - + \ No newline at end of file diff --git "a/Laboratoare/5 Verilog Secven\310\233ial/Automate finite/Teorie/index.html" "b/Laboratoare/5 Verilog Secven\310\233ial/Automate finite/Teorie/index.html" index 6b806ae..e6b277b 100644 --- "a/Laboratoare/5 Verilog Secven\310\233ial/Automate finite/Teorie/index.html" +++ "b/Laboratoare/5 Verilog Secven\310\233ial/Automate finite/Teorie/index.html" @@ -4,13 +4,13 @@ Automate de stări | Computer Architecture - +
    Skip to main content

    Automate de stări

    Automatele de stări sunt absolut necesare în implementarea oricărui circuit digital. Există două tipuri de automate de stări, clasificate după tipurile de ieșiri generate de fiecare. Primul tip este Mașina Mealy, caracterizată de faptul că una sau mai multe ieșiri depind atât de starea curentă, cât și de una sau mai multe intrări, iar al doilea este Mașina Moore, ale cărei ieșiri sunt doar o funcție care depinde doar de starea curentă.

    Mașina Mealy​

    Un model general al unei mașini secvențiale Mealy este format dintr-o rețea combinațională care generează ieșirile, starea următoare și o stare “Current State Register” reprezentând starea curentă, ca în figura de mai jos. Starea “Current State Register” este modelată utilizând bistabili D și este sensibilă la semnalul de ceas (Clock). Atât ieșirea, cât și determinarea stării următoare depind de intrare și de starea curentă.

    Mealy

    Figure: Mealy

    Exemplu de automat de stări Mealy:​

    Exemplu Mealy

    Figure: Exemplu Mealy

    module mealy_fsm(
        output reg parity,
        input clk,
        input reset,
        input x);
        
        reg state, next_state;
        parameter S0=0;
        parameter S1=1;

        // Partea secvențială
        always @(posedge clk or negedge reset)
            if (!reset)
                state <= S0;
            else
                state <= next_state;

        // Partea combinațională
        always @(*) begin
            parity = 1'b0;
            case(state)
                S0: 
                    if(x) 
                        next_state = S1;
                    else
                        next_state = S0;
                S1: 
                    if(x) begin
                        parity = 1;
                        next_state = S0;
                    end
                    else begin
                        parity = 1;
                        next_state = S1;
                    end
                default:
                    next_state = S0;
            endcase
        end
    endmodule

    Mașina Moore​

    Un model general al unei mașini secvențiale Moore este prezentat mai jos. Ieșirea sa este dependentă doar de blocul stării curente, iar starea următoare este determinată pe baza intrării și a stării curente. În schema de mai jos, starea “Current State Register” este modelată utilizând bistabili D. Mașinile Moore obișnuite sunt descrise prin intermediul a trei blocuri, dintre care unul conține logică secvențială, iar celelalte două conțin logică de tip combinațională.

    Moore

    Figure: Moore

    Exemplu de automat de stări Moore:​

    Exemplu Moore

    Figure: Exemplu Moore

    module moore_fsm(
        output reg parity,
        input clk,
        input reset,
        input x);
        
        reg state, next_state;
        parameter S0=0;
        parameter S1=1;

         // Partea secvențială
        always @(posedge clk or negedge reset)
            if (!reset)
                state <= S0;
            else
                state <= next_state;

        always @(*) begin
            case(state)
                S0: begin
                    parity = 0;
                    if (x)
                        next_state = S1;
                    else
                        next_state = S0;
                end
                S1: begin
                    parity = 1;
                    if(!x)
                        next_state = S1;
                    else
                        next_state = S0;
                end
            endcase
        end
    endmodule
    - + \ No newline at end of file diff --git "a/Laboratoare/5 Verilog Secven\310\233ial/Automate finite/index.html" "b/Laboratoare/5 Verilog Secven\310\233ial/Automate finite/index.html" index 8d64fb0..832e9b9 100644 --- "a/Laboratoare/5 Verilog Secven\310\233ial/Automate finite/index.html" +++ "b/Laboratoare/5 Verilog Secven\310\233ial/Automate finite/index.html" @@ -4,13 +4,13 @@ Automate finite | Computer Architecture - +
    Skip to main content

    Automate finite

    - + \ No newline at end of file diff --git "a/Laboratoare/5 Verilog Secven\310\233ial/Memorie/Practic\304\203/index.html" "b/Laboratoare/5 Verilog Secven\310\233ial/Memorie/Practic\304\203/index.html" index 53057d4..9622efb 100644 --- "a/Laboratoare/5 Verilog Secven\310\233ial/Memorie/Practic\304\203/index.html" +++ "b/Laboratoare/5 Verilog Secven\310\233ial/Memorie/Practic\304\203/index.html" @@ -4,13 +4,13 @@ Practice: Memory | Computer Architecture - +
    Skip to main content

    Practice: Memory

    Soluția se află în repo-ul materiei GitHub.

    -Modulul Register reprezinta cun functioneaza un registru real.Semnalele oe și we reprezintă Output Enable, respectiv Write Enable.

    - `oe` controlează ieșirea registrului. Când oe este `high` ieșirea este activă având valoarea memorată de registru. Când oe este low ieșirea va fi 0. Acest semnal trebuie să fie asincron: modificarea lui va avea efect imediat asupra ieșirii și nu se va aștepta tranziția semnalului de ceas.
    - `we` controlează scrierea în registru. Când we este high registrul va memora valoarea aflată în semnalul de intrare. Când we este low valoarea registrului nu se va modifica, ignorând practic semnalul de intrare. Acest semnal trebuie să fie sincron: modificarea valorii memorate de registru se face doar în momentul tranziției semnalului de ceas.
    - Semnalul `disp_out` este folosit pentru afișare/debugging pe display, iar valoarea acestuia trebuie să fie cea memorată de registru în momentul curent. În mod normal acest semnal nu este prezent într-un calculator. Acest semnal nu trebuie să fie afectat de oe, valoarea disponibilă pe disp_out fiind în orice moment egală cu valoarea memorată de registru.
    - Semnalul de reset `rst_n` este activ pe low (0).
    - Hint: Puteți folosi operatorul condiţional.
    • Pornind de la interfața modulului sequential_multiplier din scheletul de cod, implementați un automat de stări care să folosească instanțe parametrizate ale modulului register pentru a îndeplini următoarele funcționalități:
      • La activarea semnalului write, valorile semnalelor a și b sunt scrise în registre parametrizate corespunzător.
      • La activarea semnalului multiply, valorile din cele două registre sunt extrase, înmulțite și rezultatul adăugat într-un al treilea registru.
      • La activarea semnalului display, semnalul out va primi valoarea aflată în al treilea registru.
      • Prioritatea celor trei semnale este dată de ordinea în care au fost descrise:
        • Dacă write este activ, se ignoră semnalele multiply și display.
        • Dacă multiply este activ, se ignoră semnalul display.
    • Modulul ram_reader este o interfață simplă pentru RAM care permite citirea și scrierea în RAM. Utilizează semnalul i_w_we pentru a controla operațiile de scriere și semnalul i_w_oe pentru a controla operațiile de citire. De asemenea se specifica si adresa de la care sa fie citita/scrisa valoarea cu semnalul i_w_address
    - + \ No newline at end of file diff --git "a/Laboratoare/5 Verilog Secven\310\233ial/Memorie/Teorie/index.html" "b/Laboratoare/5 Verilog Secven\310\233ial/Memorie/Teorie/index.html" index ff77ec9..5a06dcd 100644 --- "a/Laboratoare/5 Verilog Secven\310\233ial/Memorie/Teorie/index.html" +++ "b/Laboratoare/5 Verilog Secven\310\233ial/Memorie/Teorie/index.html" @@ -4,13 +4,13 @@ Memorie | Computer Architecture - +
    Skip to main content

    Memorie

    Registrul​

    Bistabilul este o celulă de memorie având capacitate de un bit, care poate fi utilizată pentru a stoca date digitale. Pentru a extinde capacitatea de stocare în ceea ce privește numărul de biți, se va utiliza un grup de bistabili, cunoscut și sub termenul de registru. Registrul de n biți este alcătuit din n bistabili și are capacitate de stocare de n biți.

    Un registru, ca orice alt circuit secvențial este sensibil la schimbarea de front a semnalelor clk și reset. De asemenea, pentru a putea fi conectat la o magistrală, acesta are nevoie să execute două operații simple:

    • citire - informația deja existentă în registru este preluată și eliberată pe ieșirea registrului
    • scriere - informația aflată pe magistrală la un moment de timp se scrie în registru

    Pentru o vizualizare mai clară a specificațiilor unui astfel de circuit digital secvențial, studiați interfața acestuia:

    Registrul

    Figure: Registrul

    Memorie cu acces aleatoriu (RAM)​

    Memoria poate fi asociată cu creierul uman, fiind folosită pentru a stoca date și instrucțiuni. Memoria unui calculator este spațiul de stocare din calculator unde sunt păstrate datele care urmează să fie procesate și instrucțiunile necesare pentru procesare. Aceasta se împarte în mai multe elemente cu caracteristici similare, numite celule. Fiecare celulă are o adresă unică numerotată de la 0 la N-1, unde N este dimensiunea blocului de memorie (numărul de celule din memorie).

    Componenta hardware de tip memorie a unui calculator unde sunt stocate sistemul de operare, programele de bază și datele utilizate la momentul curent, pentru a fi accesate cu ușurință de procesor se numește RAM (Random Access Memory). RAM-ul este o memorie volatilă, însemnând că toate informațiile stocate în acesta vor fi pierdute la deconectarea calculatorului de la sursa electrică, urmând să fie recuperate la repornirea sistemului de pe HDD/SSD. RAM-ul este mic, atât ca dimensiune fizică, cât și din punct de vedere al capacității de stocare de date.

    În comparație cu registrele, memoria de tip RAM este mai greu de accesat de către procesor. Fiind un circuit secvențial complex sunt necesari mai mulți cicli de ceas pentru a citi/scrie informația necesară. Totodată, oferă o capacitate mult mai mare de stocare, de care registrele nu dispun. Prin urmare, pentru implementarea eficientă a unui circuit digital, este foarte importantă gestionarea resurselor între memorie și registre, astfel încât să se permită stocarea și accesul la toate informațiile necesare într-un timp cât mai scurt.

    - + \ No newline at end of file diff --git "a/Laboratoare/5 Verilog Secven\310\233ial/Memorie/index.html" "b/Laboratoare/5 Verilog Secven\310\233ial/Memorie/index.html" index 69bee39..0c6b5ad 100644 --- "a/Laboratoare/5 Verilog Secven\310\233ial/Memorie/index.html" +++ "b/Laboratoare/5 Verilog Secven\310\233ial/Memorie/index.html" @@ -4,13 +4,13 @@ Memorie | Computer Architecture - +
    Skip to main content

    Memorie

    - + \ No newline at end of file diff --git "a/Laboratoare/5 Verilog Secven\310\233ial/index.html" "b/Laboratoare/5 Verilog Secven\310\233ial/index.html" index cee34cf..6dc1f56 100644 --- "a/Laboratoare/5 Verilog Secven\310\233ial/index.html" +++ "b/Laboratoare/5 Verilog Secven\310\233ial/index.html" @@ -4,13 +4,13 @@ 5 Verilog Secvențial | Computer Architecture - +
    Skip to main content

    5 Verilog Secvențial

    - + \ No newline at end of file diff --git "a/Laboratoare/6 Verilog Secven\310\233ial/Unitate aritmetica logica/Practic\304\203/index.html" "b/Laboratoare/6 Verilog Secven\310\233ial/Unitate aritmetica logica/Practic\304\203/index.html" index 4f18115..610a4cc 100644 --- "a/Laboratoare/6 Verilog Secven\310\233ial/Unitate aritmetica logica/Practic\304\203/index.html" +++ "b/Laboratoare/6 Verilog Secven\310\233ial/Unitate aritmetica logica/Practic\304\203/index.html" @@ -4,13 +4,13 @@ Practică: Implementare modul UAL | Computer Architecture - +
    Skip to main content

    Practică: Implementare modul UAL

    Conținutul laboratorului este prezent la următorul link.

    Vom completa conținutul modulului alu, folosind intrările și ieșirile prezentate mai jos.

    module alu #(
        parameter p_data_width = 5, // 5 for FPGA testing, 16 for Simulation and inside the CPU
        parameter p_flags_width = 5
    )(
        output wire [(p_data_width-1):0] o_w_out,
        output wire [(p_flags_width-1):0] o_w_flags,
        input wire [(p_data_width-1):0] i_w_op1,
        input wire [(p_data_width-1):0] i_w_op2,
        input wire [3:0] i_w_opcode,
        input wire i_w_carry,
        input wire i_w_oe
    );

    Codurile de identificare ale operațiilor (cei 4 biți S) sunt definite în modulul alu.v din scheletul de laborator și în codul de mai jos.

    localparam ADC  = 4'd0;
    localparam SBB1 = 4'd1;
    localparam SBB2 = 4'd2;
    localparam NOT  = 4'd3;
    localparam AND  = 4'd4;
    localparam OR   = 4'd5;
    localparam XOR  = 4'd6;
    localparam SHL  = 4'd7;
    localparam SHR  = 4'd8;
    localparam SAR  = 4'd9;

    Operațiile​

    Partea combinațională a modulului descrie comportamentul fiecărei operații în funcție de codul operațional i_w_opcode prin intermediul unei structuri case.

    Adunarea cu carry (ADC)​

    Se execută adunarea celor 2 operanzi și carry, iar în cazul în care rezultatul depășește ca mărime parametrul p_data_width, bitul în plus activează flag-ul carry.

    Flag-ul de overflow este activat cu 2 condiții:

    1. MSB-ul operanzilor este egal. Acest bit indică dacă operandul este un număr pozitiv sau negativ, iar suma dintre două numere de semn opus nu poate depăși intervalul lor.
    2. MSB-ul rezultatului diferă de cel al operanzilor, indicând că a avut loc overflow-ul
    ADC: begin
        {l_r_carry, l_r_result} = i_w_op1 + i_w_op2 + i_w_carry;
        l_r_overflow = (i_w_op1[p_data_width-1] == i_w_op2[p_data_width-1]) &&
                        (i_w_op1[p_data_width-1] != l_r_result[p_data_width-1]);
    end

    Scăderile (SBB1/SBB2)​

    Condițiile pentru activarea semnalelor de carry și overflow sunt asemănătoare cu cele din cazul adunării, cu excepția primei condiții de overflow, care e inversată.

    i_w_op2[p_data_width-1] != i_w_op1[p_data_width-1]

    Operațiile logice (AND/OR/XOR/NOT) și de shift (SHL/SHR/SAR)​

    Se observă că operațiile logice nu activează semnalele carry și overflow, iar în cazul operațiilor cu un singur operand (NOT/SHL/SHR/SAR), datorită operatorului |, acesta se poate afla pe oricare din intrări i_w_op1 sau i_w_op2 cu condiția ca cealaltă să aibă valoarea 0.

    De asemenea operația SAL lipsește întrucât e identică cu SHL.

    Operatiile de shift la stanga verifica MSB-ul operandului pentru activarea flag-ului carry, iar operatiile de shift la dreapta verifica LSB-ul.

    // SHL/SAL
    l_r_carry = i_w_op1[p_data_width-1] | i_w_op2[p_data_width - 1];

    // SHR/SAR
    l_r_carry = i_w_op1[0] | i_w_op2[0];

    Pentru activarea flagului overflow operatiile de shift verifica schimbarea MSB-ului deoarece acesta este bitul de semn.

    Zero (Z), Sign (S), Parity (P)​

    Aceste semnale au aceleași condiții de activare indiferent de operația efectuată. De asemenea paritatea este verificată prin operatorul de reducere XNOR.

    l_r_zero = l_r_result == 0;
    l_r_sign = l_r_result[p_data_width-1];
    l_r_parity = ~^l_r_result;

    Extra operations​

    XNOR​

    MUL​

    DIV​

    MOD​

    - + \ No newline at end of file diff --git "a/Laboratoare/6 Verilog Secven\310\233ial/Unitate aritmetica logica/Teorie/index.html" "b/Laboratoare/6 Verilog Secven\310\233ial/Unitate aritmetica logica/Teorie/index.html" index cde35b9..ffc4420 100644 --- "a/Laboratoare/6 Verilog Secven\310\233ial/Unitate aritmetica logica/Teorie/index.html" +++ "b/Laboratoare/6 Verilog Secven\310\233ial/Unitate aritmetica logica/Teorie/index.html" @@ -4,13 +4,13 @@ Unitatea aritmetică-logică (UAL) | Computer Architecture - +
    Skip to main content

    Unitatea aritmetică-logică (UAL)

    Unitatea aritmetică-logică este responsabilă de efectuarea operațiilor aritmetice și logice în timpul execuției instrucțiunilor. Operațiile primesc unul sau doi operanzi, iar UAL-ul în afară de producerea rezultatului setează și o serie de indicatori de condiții (eng. flags) rezultați în urma operațiilor. Operațiile disponibile în UAL derivă din instrucțiunile prezente în setul de instrucțiuni al procesorului didactic, însă nu au neapărat o corespondență 1-la-1 cu acestea. Unele operații sunt folosite în mai multe instrucțiuni, iar unele instrucțiuni folosesc mai multe operații. UAL-ul trebuie însă proiectat în așa fel astfel încât să cuprindă toate operațiile necesare în execuția instrucțiunilor disponibile în procesorul didactic.

    Unitatea aritmetică-logică

    Figure: Unitatea aritmetică-logică

    Operanzii pe 16 biți sunt op1 și op2, iar cei 4 biți S selectează operația ce va fi efectuată. Rezultatul este pus pe magistrală prin activarea semnalului Enable. Acesta este dezactivat de instrucțiunile care nu au nevoie de fapt de rezultatul operației, ci doar de indicatori (ex: cmp, test). Operațiile de adunare și scădere folosesc și un bit de carry/borrow reprezentat prin semnalul Carry. Acesta este activat selectiv de instrucțiunile ADD/ADC (add with carry) și SUB/SBB (subtract with borrow), precum și alte instrucțiuni, pentru a obține rezultatul dictat de semantica instrucțiunii.

    Descrierea generală a registrului care conține indicatorii de condiții (IND)​

    Registrul de indicatori constituie o grupare a unor bistabili cu funcții individuale, poziționați la execuția instrucțiunilor, în funcție de rezultatul din unitatea aritmetică logică. Registrul IND permite alegerea unei secvențe de execuție următoare unei instrucțiuni aritmetice/logice, în funcție de rezultatul operației.

    Descrierea detaliată a indicatorilor de condiții​

    • T/C (transport, eng: carry): Este setat (poziționat în "1") dacă în urma unei adunări rezultă un transport dinspre rangul cel mai semnificativ, altfel T este șters (trecut în "0").
      • Este setat dacă în urma unei scăderi rezultă un împrumut în cel mai semnificativ bit al rezultatului, altfel este șters.
      • Poate fi interpretat ca depășire în instrucțiunile cu numere întregi fără semn. Poate fi utilizat în instrucțiunile ADC și SBB pentru a efectua operații aritmetice în precizie multiplă. Poate fi testat cu instrucțiuni de salt condiționat.
    • S (semn):
      • La execuția operațiilor aritmetice și logice, indicatorul S este setat la valoarea bitului cel mai semnificativ al rezultatului (bitul de semn).
        • Pentru numere cu semn (în absența depășirii) S=0 indică rezultat pozitiv iar S=1 indică rezultat negativ.
        • În cazul operațiilor cu numere fără semn S poate fi ignorat deoarece în acest caz specifică cel mai semnificativ bit al rezultatului.
      • Poate fi testat cu instrucțiuni de salt condiționat.
    • Z (zero):
      • Este setat dacă în urma unei operații aritmetice sau logice se obține rezultat egal cu 0, altfel Z este șters.
      • Poate fi testat cu instrucțiuni de salt condiționat pentru a dirija secvența de execuție a instrucțiunilor în funcție de valoarea rezultatului.
    • P (paritate):
      • Indicatorul de paritate P este setat dacă în urma execuției unei operații aritmetice sau logice rezultatul conține un număr par de biți egali cu 1, altfel P este șters.
      • Poate fi testat cu instrucțiuni de salt condiționat.
    • D/O (depașire, eng: overflow):
      • Indicatorul de depășire D (eng. overflow) este setat dacă în urma execuției unei operații aritmetice rezultatul este un număr pozitiv prea mare sau un număr negativ prea mic pentru a putea fi reprezentat în operandul destinație (exclusiv bitul de semn); altfel D este șters.
      • Poate fi interpretat ca depășire în instrucțiunile cu numere întregi cu semn și poate fi testat cu instrucțiuni de salt condiționat.
      • Poate fi ignorat în operațiile aritmetice cu numere întregi fără semn.
      • Exemple:
        • În cazul unei operații cu semn, pe 4 biți: 0100 + 0100 = 1000 (indicatorul de depășire e setat)
        • 1000 + 1000 = 0000 (indicatorul de depășire e setat)
        • 0110 + 1001 = 1111 (indicatorul de depășire este șters)
        • 0100 + 0110 = 1010 (indicatorul de depășire este setat, iar cel de transport este șters)
      • Detalii despre situații în care apare depășirea și cum se detectează găsiți aici și aici.

    Observații referitoare la indicatorii de condiții:

    • pentru operații între numere întregi fără semn contează indicatorul de transport/carry (T/C), pentru cele cu semn contează indicatorul de depășire/overflow (D/O).
    • indicatorul de paritate (P) este 1 în caz ca avem un număr par de biți, altfel este 0 (deci paritate impară, altfel se numea paritate pară - 0 pentru număr par de biți, 1 pentru număr impar). Metoda de determinare a acestuia constă în aplicarea unui xor negat între biții cuvântului (dacă era paritate pară aplicam xor simplu).
    • unele operații au efect asupra tutoror indicatorilor de condiție (exemplu ADD), altele însă afectează doar o parte dintre aceștia.

    Descriere operații​

    • ADC:
      • ADC este un Full Adder, în care intrările sunt cei doi operanzi și carry-ul.
      • Flag-uri setate: T/C, S, Z, P, D/O.
    • SBB1:
      • SBB1 scade operandul op2 și bitul Carry din operandul op1.
      • Flag-uri setate: T/C, S, Z, P, D/O.
    • SBB2:
      • SBB2 scade operandul op1 și bitul Carry din operandul op2.
      • Flag-uri setate: T/C, S, Z, P, D/O.
    • NOT:
      • NOT inversează individual fiecare bit al operandului.
      • Flag-uri setate: S, Z, P (T/C și D/O sunt întotdeauna 0 în cazul operațiilor logice).
    • AND:
      • AND efectuează "ȘI" logic între biții celor doi operanzi.
      • Flag-uri setate: S, Z, P (T/C și D/O sunt întotdeauna 0 în cazul operațiilor logice).
    • OR:
      • OR efectuează "SAU" logic între biții celor doi operanzi.
      • Flag-uri setate: S, Z, P (T și D sunt întotdeauna 0 în cazul operațiilor logice).
    • XOR:
      • XOR efectuează "SAU-exclusiv" între biții celor doi operanzi.
      • Flag-uri setate: S, Z, P (T și D sunt întotdeauna 0 în cazul operațiilor logice).
    • SHL/SAL:
      • SHL/SAL realizează deplasarea la stânga cu o poziție a operandului.
      • În bitul cel mai puțin semnificativ se introduce zero. Deplasarea logică și aritmetică la stânga cu o poziție produc același rezultat.
      • Flag-uri setate: S, Z, P, T (conține întotdeauna bitul deplasat în afară), D (e setat pe 1 doar dacă în urma operației bitul cel mai semnificativ - de semn - și-a schimbat valoarea, altfel e 0)
    • SHR:
      • SHR deplasează la dreapta biții operandului, introducând zero în bitul cel mai semnificativ.
      • Flag-uri setate: S, Z, P, T (conține întotdeauna bitul deplasat în afară), D (e setat pe 1 doar dacă în urma operației bitul cel mai semnificativ - de semn - și-a schimbat valoarea, altfel e 0)
    • SAR:
      • SAR deplasează aritmetic la dreapta biții operandului.
      • Deplasarea se face cu extensia bitului de semn (bitul de semn rămâne neschimbat iar bitul cel mai semnificativ de date preia conținutul bitului de semn).
      • Flag-uri setate: S, Z, P, T (conține întotdeauna bitul deplasat în afară), D (e setat pe 1 doar dacă în urma operației bitul cel mai semnificativ - de semn - și-a schimbat valoarea, altfel e 0)

    Operațiile de shiftare​

    Operațiile de shiftare se împart în: shiftare logică, shiftare aritmetică, shiftare circulară fără carry, shiftare circulară cu carry. În acest laborator vom trata primele două tipuri de operații.

    Shiftare logică​

    O shiftare logică nu ține cont de semnul operandului. În cazul shiftării logice se ține cont doar de ordinea biților, iar pozițiile care rămân libere sunt umplute cu zerouri.

    În imaginile de mai jos se poate observa modul de execuție a shiftărilor logice.

    Shiftare logică la stânga

    Figure: Shiftare logică la stânga

    Shiftare logică la dreapta

    Figure: Shiftare logică la dreapta

    Iar în figurile de mai jos găsiți un exemplu practic de efectuare a shiftărilor logice spre stânga (SHL) și spre dreapta (SHR).

    Exemplu de shiftare logică la stânga

    Figure: Exemplu de shiftare logică la stânga

    Exemplu de shiftare logică la dreapta

    Figure: Exemplu de shiftare logică la dreapta

    În Verilog, operatorii de shiftare logică sunt << și >>.

    Shiftare aritmetică​

    Spre deosebire de shiftarea logică spre dreapta (SHR), shiftarea aritmetică spre dreapta (SAR) nu umple spațiile rămase libere cu zerouri. În cazul SAR, spațiile rămase libere se umplu cu valoarea bitului cel mai semnificativ, care se replică de câte ori este nevoie (vezi imaginea de mai jos).

    Exemplu de shiftare aritmetică la dreapta

    Figure: Exemplu de shiftare aritmetică la dreapta

    Exemplu de shiftare aritmetică la dreapta

    Figure: Exemplu de shiftare aritmetică la dreapta

    În Verilog, operatorii de shiftare aritmetică sunt <<< și >>>.

    Aceștia au efectul scontat doar dacă variabila a fost declarată signed (ex: reg signed [15:0] a;).

    Important: Shiftarea logică spre stânga (SHL) și shiftarea aritmetică spre stânga (SAL) se efectuează în același mod. Se păstrează, însă, ambele mnemonici (SHL / SAL) pentru a se putea păstra contextul folosirii acestora, logic sau aritmetic.

    Important: Rezultatul shiftării cu n biți la stânga este echivalent cu înmulțirea cu 2n2^n. Shiftarea la dreapta cu n biți este echivalentă cu împărțirea la 2n2^n.

    - + \ No newline at end of file diff --git "a/Laboratoare/6 Verilog Secven\310\233ial/Unitate aritmetica logica/index.html" "b/Laboratoare/6 Verilog Secven\310\233ial/Unitate aritmetica logica/index.html" index 98b299f..1bb1ec8 100644 --- "a/Laboratoare/6 Verilog Secven\310\233ial/Unitate aritmetica logica/index.html" +++ "b/Laboratoare/6 Verilog Secven\310\233ial/Unitate aritmetica logica/index.html" @@ -4,13 +4,13 @@ Unitate aritmetica logica | Computer Architecture - +
    Skip to main content

    Unitate aritmetica logica

    📄️ Teorie

    Unitatea aritmetică-logică este responsabilă de efectuarea operațiilor aritmetice și logice în timpul execuției instrucțiunilor. Operațiile primesc unul sau doi operanzi, iar UAL-ul în afară de producerea rezultatului setează și o serie de indicatori de condiții (eng. flags) rezultați în urma operațiilor. Operațiile disponibile în UAL derivă din instrucțiunile prezente în setul de instrucțiuni al procesorului didactic, însă nu au neapărat o corespondență 1-la-1 cu acestea. Unele operații sunt folosite în mai multe instrucțiuni, iar unele instrucțiuni folosesc mai multe operații. UAL-ul trebuie însă proiectat în așa fel astfel încât să cuprindă toate operațiile necesare în execuția instrucțiunilor disponibile în procesorul didactic.

    - + \ No newline at end of file diff --git "a/Laboratoare/6 Verilog Secven\310\233ial/index.html" "b/Laboratoare/6 Verilog Secven\310\233ial/index.html" index f11a686..f6774c8 100644 --- "a/Laboratoare/6 Verilog Secven\310\233ial/index.html" +++ "b/Laboratoare/6 Verilog Secven\310\233ial/index.html" @@ -4,13 +4,13 @@ 6 Verilog Secvențial | Computer Architecture - +
    Skip to main content

    6 Verilog Secvențial

    - + \ No newline at end of file diff --git a/Laboratoare/7 Calculator Didactic/Arhitectura/Teorie/index.html b/Laboratoare/7 Calculator Didactic/Arhitectura/Teorie/index.html index d758e09..94d138e 100644 --- a/Laboratoare/7 Calculator Didactic/Arhitectura/Teorie/index.html +++ b/Laboratoare/7 Calculator Didactic/Arhitectura/Teorie/index.html @@ -4,14 +4,14 @@ Arhitectura Calculatorului Didactic | Computer Architecture - +
    Skip to main content

    Arhitectura Calculatorului Didactic

    Caracteristici ale calculatorului didactic​

    • Arhitectura bazată pe Registre Generale

      • Calculatorul dispune de 8 Registre Generale

    • Arhitectura pe 16 biţi:

      • Registrele generale au dimensiunea de 16 biţi
      • Unitatea aritmetico-logică (UAL) prelucrează operanzi pe 16 biţi
      • Magistrala procesorului (MAG) este pe 16 biţi
      • Spaţiul de adresare este de 2162^{16} Cuvinte, adică 64 Kcuvinte

    • UAL pentru întregi reprezentaţi în cod complementar

      • Procesorul dispune de o singură unitate aritmetică-logică ce operează cu întregi cu semn pe 16 biţi

    • Moduri de adresare complexe

      • Setul de instrucţiuni şi modurile de adresare derivă din arhitectura x86
      • Modurile de adresare sunt specifice procesoarelor CISC
        • Lucrul cu operanzi din memorie, fără încărcare prealabilă în registrele generale
        • Modurile de adresare sunt numeroase şi foarte flexibile

    Arhitectura setului de instrucţiuni (ISA - Instruction Set Architecture) este folosită pentru a abstractiza funcţionarea internă a unui procesor. ISA defineşte “personalitatea” unui procesor: cum funcţionează procesorul d.p.d.v. al programatorului, ce fel de instrucţiuni execută, care este semantica acestora. ISA este cea mai importantă parte a design-ului unui procesor; alte aspecte cum sunt componentele de calcul și stocare, interacţiunea cu memoriile, pipeline-ul, fluxul de date în procesor putând fi schimbate de la o versiune la alta a procesorului. La ora actuală există două filozofii de design pentru un procesor: Complex Instruction Set Computer (CISC) şi Reduced Instruction Set Computer (RISC). În afară de acestea există şi ISA-uri pentru procesoare specializate, cum sunt GPU-urile pentru plăci grafice si DSP-urile pentru procesare de semnal.

    Principalele categorii de instrucțiuni sunt cele aritmetico-logice, de control secvențial, și respectiv de acces la memorie. Formatul instrucțiunilor RISC are o lungime fixă, cu lungimea unei instrucțiuni în general egală cu lungimea cuvantului de memorie; în cazul CISC, lungimea unei instrucțiuni variază în funcție de formatul instrucțiunii. RISC are un număr mic de moduri de adresare, spre deosebire de CISC, care are un număr mare de moduri de adresare (dar care nu sunt totdeauna utilizate).

    Setul de instrucțiuni RISC este orientat pe registre (peste 32 de registre). Pentru că accesul la memorie e mult mai lent decât lucrul cu registrele, RISC încurajează lucrul cu aceștia. Face acest lucru prin creșterea numărului de registreși prin limitarea explicită a acceselor la memorie. În general instrucțiunile au 2 operanzi (registre) și un registru destinație. Ca principiu, arhitectura RISC are mai multe registre generale, în timp ce CISC are mai mulți speciali. Practic toate procesoarele moderne împrumută atât caracteristici CISC, cât și RISC.

    În cadrul arhitecturilor RISC există o limitare explicită, și anume: singurul mod de acces la memorie este prin load și store. Aceasta se deosebește fundamental de CISC care are instrucțiuni cu operanzi locații de memorie. Totuși, deși RISC impune această disciplină de lucru cu memoria, doar 20-25% din codul unui program e reprezentat de loads & stores.

    Observaţii

    • Procesorul didactic este consistent din punctul de vedere al dimensiunii: 16 biţi. Procesoarele reale, în marea lor majoritate, nu respectă aceasta regulă. Spre exemplu, Pentium 4 cu arhitectura pe 32 de biţi (IA-32) include registre pe 128 de biţi şi dispune de o magistrală de adrese pe 36 de biţi (spaţiul total de adresare este de 64 TB). În consecinţă părerile sunt impărţite în legătură cu care ar fi o definiţie corectă pentru dimensiunea procesorului. Cea mai frecventă definiţie spune că dimensiunea unui procesor este dată de dimensiunea registrelor şi a unităţilor aritmetico-logice.
    • Spaţiul de adresare pentru un procesor pe N biţi este de 2N locaţii de memorie. În funcţie de organizarea acesteia însă, aceste locaţii pot fi octeţi sau cuvinte de mai multi octeţi. Memoria calculatorului didactic este organizată ca un spaţiu contiguu de 64 Kcuvinte de 16 biţi fiecare. Aşadar spaţiul total de adresare pentru calculatorul didactic este de 128 Kbytes. Memoria din calculatoarele voastre însă este adresabilă la nivel de octet. Dacă calculatorul didactic ar fi fost echipat cu o astfel de memorie, spaţiul de adresare ar fi fost de 64 KB, deoarece la fiecare locaţie se poate stoca fix un byte.
    • Prin faptul ca procesorul permite lucrul cu operanzi direct din memorie se înţelege că ei nu trebuie aduşi în prealabil de către programator într-un registru general. Cu toate acestea nu se poate lucra cu ambii operanzi direct din memorie. Acest tip de procesare specific arhitecturilor CISC poartă numele de procesare Registru-Memorie. Spre deosebire de aceasta, arhitecturile RISC tipice necesită încărcarea prealabilă a operanzilor în registrele generale. De aceea, aceste procesoare se mai numesc Registru-Registru sau Load/Store. Arhitecturile Memorie-Memorie sunt foarte rare, datorită complexităţii hardware-ului şi performanţelor scăzute.

    Resursele calculatorului didactic​

    Arhitectura calculatorului didactic

    Figure: Arhitectura calculatorului didactic

    Magistrala MAG​

    Interconectarea tuturor resurselor se realizează prin intermediul unei magistrale, MAG, care constituie suportul fizic de comunicație între aceste resurse. Dimensiunea magistralei este de 16 linii. Deoarece magistrala este în totalitate pasivă (este un set de conductori), un singur cuvânt de informație poate exista pe magistrală la un moment dat.

    Registrele Generale RG​

    Deoarece timpul de acces la memoria M este relativ mare (de ordinul zecilor de nanosecunde) procesorul dispune de 8 registre generale de câte 16 biți, fiecare ce lucrează la frecvența de ceas a procesorului. În tabelul de mai jos sunt sumarizate funcțiile acestora:

    RegistrulFuncția
    RA, RB, RCLa dispoziția programatorului pentru stocarea operanzilor. RA este folosit în lucrul cu porturile.
    ISIndicatorul de stivă.
    XA, XBSe pot folosi pentru stocarea operanzilor. Sunt folosiți pentru adresarea memoriei ca și registre index.
    BA, BBSe pot folosi pentru stocarea operanzilor. Sunt folosiți pentru adresarea memoriei ca și registre de bază.

    Unitatea aritmetică logică UAL​

    Unitatea aritmetică logică (UAL) realizează operațiile aritmetice și logice ale calculatorului didactic. Ea este utilizată pentru prelucrarea datelor și pentru calculul adresei efective. Unitatea aritmetică logică prelucrează operanzi pe 16 biți reprezentați în cod complementar. Caracteristicile rezultatului (zero, par, transport și depășire) sunt depuse într-un registru de indicatori IND, în urma execuției oricărei instrucțiuni aritmetice-logice.

    Memoria M​

    Memoria este utilizată pentru a păstra informații reprezentând date sau instrucțiuni. Memoria M este o matrice de elemente de memorare organizată într-un spațiu de adresare unic de 65536 cuvinte a câte 16 biți fiecare. Astfel, capacitatea memoriei este de 64Kcuvinte x 2 octeti = 128 KB.

    Registrul AM​

    Registrul de adresare a memoriei, AM, păstrează adresa celulei de memorie la care se face acces la un moment dat. Când se dorește realizarea unei operații de citire din memorie, adresa solicitată va fi depusă în acest registru, iar unitatea de comandă va lansa comanda «Memory Read». După un anumit timp, memoria va furniza pe magistrală cuvantul de la adresa solicitată. Analog, când se dorește să se scrie la o anumită adresă din memorie un cuvant, aceasta este depusă în registrul AM, datele de scris sunt activate pe magistrală, iar unitatea de comandă va lansa comanda «Memory Write».

    Registrul Contor Program CP​

    Registrul contor program CP este utilizat pentru păstrarea adresei instrucțiunii ce urmează să se execute după terminarea execuției instrucțiunii curente. Registrul CP va fi inițializat cu o valoare dată la pornirea sau resetarea sistemului. După încărcarea fiecarei instrucțiuni, el se va incrementa pentru a marca avansul la următoarea instrucțiune. În cazul în care instrucțiunea executată este una de salt, adresa de salt va fi încărcata în CP în urma execuției instrucțiunii.

    Registrul de instrucțiuni RI​

    Registrul de instrucțiuni RI păstrează instrucțiunea în curs de execuție. Conținutul său este folosit de unitatea de comandă în vederea generării semnalelor de comandă pentru toate resursele.

    Prin activarea ieșirii lui RI, cu ri_oe, doar deplasamentul este pus pe magistrală pentru a putea fi folosit în calcule (biții 8:15 sunt inversați și extinși la 16 biți prin multiplicarea bitului de semn pentru calculul adresei în instrucțiunile de salt condiționat).

    Indicatorii de condiții IND​

    Registrul de indicatori constituie o grupare a unor flag-uri provenite din rezultatele instrucțiunilor de tip aritmetico-logic. Registrul IND permite unei instrucțiuni să folosească informații rezultate în urma execuției unei instrucțiuni anterioare.

    Spre exemplu, dacă se dorește efectuarea unei sume cu operanzi pe 32 de biți, din moment ce dimensiunea procesorului este 16 biți, este nevoie să se prelucreze pe rând octeții inferiori, apoi octeții superiori. Cei doi operanzi vor ocupa două adrese consecutive de memorie, fie ele 0xA16, 0xA17 pentru primul, respectiv 0xA18, 0xA19 pentru cel de-al doilea. Suma va fi depusă la adresele 0xA20, 0xA21.

    Iată programul în assembler pentru situația prezentată anterior:

    MOV RA, [0xA16]
    MOV RB, [0xA18]
    ADD RA, RB
    MOV [0xA20],RA
    MOV RA, [0xA17]
    MOV RB, [0xA19]
    ADC RA, RB
    MOV [0xA21],RA

    După cum se poate observa, cea de-a doua operație aritmetică este ADC, adică adunare cu transport (carry). Semnificația este următoarea: dacă de la operația anterioară de adunare a apărut transport, acest transport va trebui propagat în octeții superiori. Astfel, operația ADD, în cazul în care a apărut transport, setează bitul T din registrul IND. Operația ADC realizează suma între operanzi, dar include în calcul și acest bit de transport.

    Un alt exemplu este saltul condiționat. O instrucțiune de tip «if (a==2)» se va implementa astfel:

    CMP RA,2
    JNE etichetă

    Prima instrucțiune are ca efect scăderea conținutului registrului RA cu 2. Rezultatul acestei operații nu se stochează, însă, ca orice operație aritmetico-logică, va afecta registrul de indicatori. Astfel, dacă rezultatul a fost zero (continutul lui RA a fost 2), se va seta flagul Z (zero) din registrul IND. Următoarea instrucțiune, JNE (jump if not equal) va testa acest flag și în functie de valoarea sa va realiza sau nu saltul.

    Registrele temporare T1,T2​

    Registrele temporare T1 și T2 sunt utilizate pentru a păstra operanzii unei operații executate în unitatea aritmetică logică, precum și rezultate intermediare la calcularea adresei efective. Ele nu sunt accesibile în mod explicit programatorului.

    Pentru a explica necesitatea existenței acestor registre, să consideram că ele nu ar fi existat. În acest caz, am fi obținut următoarea schemă:

    UAL fără registre temporare

    Figure: UAL fără registre temporare

    În acest caz, ambii operanzi precum și rezultatul operației ar trebui să se găsească simultan pe magistrală, ceea ce este imposibil.

    Subsistemul de Intrări/Ieșiri​

    Subsistemul de intrări și ieșiri permite procesorului comunicația cu mediul extern prin intermediul dispozitivelor periferice. Subsistemul este format din interfețe (spre exemplu interfațele serială, paralelă, IDE, USB, etc.) capabile să comunice cu dispozitivele periferice în conformitate cu un standard. Aceste interfețe includ un set de registre (de date/stări/comenzi) pentru comunicația cu procesorul. De exemplu, când procesorul dorește să transmită un cuvânt de date prin interfața USB, el va depune în registrul de date asociat interfeței USB cuvântul respectiv, apoi va scrie în registrul de comenzi comanda de transmisie. Fiecare astfel de registru este identificat printr-o adresă unică în sistem și poartă numele de port de intrare/ieșire. Așadar, totalitatea registrelor asociate interfețelor din sistem (porturilor) este echivalentă cu o memorie în care fiecare adresă este asociată unei interfețe.

    Registrul de adrese de intrare/ieșire AIE​

    Întrucât subsistemul de intrări/ieșiri apare procesorului ca o memorie în care fiecare locație reprezintă un port asociat unei interfețe, ca și în cazul memoriei este nevoie de un registru de adrese. Acesta va fi folosit pentru a stoca adresa portului cu care se dorește să se comunice. Spre exemplu, atunci când procesorul vrea să transmită ceva pe interfața paralelă, el va depune în registrul AIE valoarea 0x378 (ce identifică portul asociat interfeței paralele), va activa pe magistrală cuvantul de date ce se dorește a fi transmis, iar unitatea de comandă va lansa semnalul «I/O Write» ce va determina încărcarea cuvântului în registrul interfeței paralele.

    Unitatea de comandă​

    Toate resursele prezentate până în acest punct formează unitatea de execuție. Unitatea de comandă dirijează aceste resurse pentru a executa o instrucțiune sau o alta. Spre exemplu, în cazul instrucțiunii ADD RA, RB unitatea de comandă va genera urmatoarea secvență de semnale:

    • Semnal către blocul de registre generale pentru a determina activarea conținutului lui RA pe magistrală.
    • Semnal către T1 pentru a încărca valoarea aflata în acest moment pe magistrală.
    • Semnal către blocul de registre generale pentru a determina activarea conținutului lui RB pe magistrală.
    • Semnal către T2 pentru a încărca valoarea aflată în acest moment pe magistrală.
    • Semnal către UAL ce indică operația de adunare.
    • Semnal către IND pentru a seta flag-urile Z, S, D, T, P.
    • Semnal către blocul de registre generale pentru a încărca în RA valoarea de pe magistrală.

    Cu alte cuvinte, unitatea de comandă este cea care controlează funcționarea procesorului. Ea dirijează întreg procesul de citire-interpretare-execuție a instrucțiunilor.

    - + \ No newline at end of file diff --git a/Laboratoare/7 Calculator Didactic/Arhitectura/index.html b/Laboratoare/7 Calculator Didactic/Arhitectura/index.html index aa87e92..689fe6e 100644 --- a/Laboratoare/7 Calculator Didactic/Arhitectura/index.html +++ b/Laboratoare/7 Calculator Didactic/Arhitectura/index.html @@ -4,13 +4,13 @@ Arhitectura | Computer Architecture - +
    Skip to main content

    Arhitectura

    - + \ No newline at end of file diff --git a/Laboratoare/7 Calculator Didactic/index.html b/Laboratoare/7 Calculator Didactic/index.html index 35d7df1..8a5709d 100644 --- a/Laboratoare/7 Calculator Didactic/index.html +++ b/Laboratoare/7 Calculator Didactic/index.html @@ -4,13 +4,13 @@ 7 Calculator Didactic | Computer Architecture - +
    Skip to main content

    7 Calculator Didactic

    - + \ No newline at end of file diff --git a/Laboratoare/8 Calculator Didactic/Unitate de comanda/Teorie/index.html b/Laboratoare/8 Calculator Didactic/Unitate de comanda/Teorie/index.html index 22f8301..1a45f7d 100644 --- a/Laboratoare/8 Calculator Didactic/Unitate de comanda/Teorie/index.html +++ b/Laboratoare/8 Calculator Didactic/Unitate de comanda/Teorie/index.html @@ -4,13 +4,13 @@ Unitatea de comandă | Computer Architecture - +
    Skip to main content

    Unitatea de comandă

    Ne vom familiariza cu formatul instrucțiunilor calculatorului didactic și cu modul de funcționare al unității de comandă. În acest scop se vor implementa în Verilog interpretarea și comandarea execuției pentru instrucțiunile specificate în arhitectura calculatorului didactic studiat la curs.

    Componentele calculatorului didactic implementate anterrio registre, UAL formează unitatea de execuție a procesorului. Pentru ca acestea să rețină date și să execute instrucțiunile procesorului, avem nevoie de o logică hardware de comandă a acestora, logică implementată în unitatea de comandă.

    În interiorul unui procesor, instrucțiunile trec prin mai multe etape. Pentru calculatorul didactic avem următoarele etape:

    • Fetch - aducerea instrucțiunii din memorie în registrul instrucțiune (RI)
    • Decode - decodificarea instrucțiunii
    • Load - încărcarea operanzilor
    • Execute - executarea instrucțiunii
    • Store - scrierea rezultatului (dacă este cazul)

    Unitatea de comandă este implicată în toate etapele de mai sus: comandă prin semnalare aducerea codurilor instrucțiunilor din memorie, le decodifică și transmite semnale către unitățile (registre, UAL, memorie) implicate în execuția acelor instrucțiuni. La terminarea execuției fiecărei instrucțiuni se comandă scrierea rezultatului (dacă este cazul) și se actualizează registrul CP (Contor Program) cu adresa instrucțiunii următoare.

    Ce trebuie să facă unitatea de comandă atunci când trebuie executată o instrucțiune aritmetică logică cu un operand? De exemplu INC RA.

    • Semnale către CP și AM: valoarea din CP e pusă pe magistrală și scrisă în AM;
    • Semnale către AM și memorie pentru a lua valoarea (codul instrucțiunii) de la adresa specificată de AM;
    • Semnal către RAM pentru a pune valoarea pe magistrală și către RI pentru a pune codul instrucțiunii în el;
    • Decodificare instrucțiune;
    • Semnal către blocul de registre generale pentru a determina activarea conținutului lui RA pe magistrală și semnal către T1 pentru a încărca valoarea aflată în acest moment pe magistrală;
    • Semnal către UAL ce indică operația INC;
    • Semnal către IND pentru ca UAL-ul să poată scrie flagurile;
    • Semnal către blocul de registre generale pentru a încărca în RA valoarea de pe magistrală;
    • Incrementarea CP pentru adresa instrucțiunii următoare - semnal către CP pentru a scrie în el.

    Implementare​

    Unitatea de comandă este implementată ca un automat de stări. Modulul acesteia are următoarele semnale:

    • intrări: clk, rst, ri (codul instrucțiunii), ind (indicatorii de condiție)
    • ieșiri:
      • semnale oe (output-enable) și we (write-enable) pentru registre, bancul de registre, memorie și unitatea aritmetică logică (doar oe)
      • alu_opcode - codul operației ce trebuie efectuată de unitatea aritmetică logică
      • alu_carry - carry-ul folosit de UAL în cadrul operației ce trebuie să o execute
      • regs_addr - indexul unui registru din bancul de registre
      • ind_sel - controlează sursa de scriere în registrul IND (0 = bus, 1 = alu flags)

    Automatul trebuie să ofere stări pentru:

    • aducerea instrucțiunii din memorie în registrul RI
    • decodificarea codului instrucțiunii pentru identificarea operației ce trebuie efectuate și a operanzilor acesteia (dacă este cazul)
    • interpretarea fiecărei instrucțiuni. Aceasta se traduce printr-o serie de stări care setează semnalele de output ale modulului pentru a comanda execuția instrucțiunii.
    • incrementarea registrului CP

    În implementarea unității de comandă vom considera că UAL-ul va pune rezultatul în T1, și de acolo va fi transferat în registre sau în memorie. Această convenție face mai simple și mai clare stările care comandă execuția operațiilor aritmetice-logice.

    Codificarea instrucțiunilor​

    Formatul instrucțiunilor calculatorului didactic

    Figure: Formatul instrucțiunilor calculatorului didactic

    • COP - codul operației, 7 biți
      • bitul [0] - separă instrucțiunile care folosesc o adresă efectivă de cele care nu folosesc:
        • 0 - instrucțiuni cu calcul de adresă efectivă
        • 1 - instrucțiuni fără calcul de adresă efectivă (salturi condiționate, RET etc.)
      • bitul [1] - separă instrucțiunile care au 1 operand de cele cu 2 operanzi:
        • 0 - un operand
        • 1 - doi operanzi
      • bitul [2] - separă instrucțiunile cu operand imediat de cele fără operand imediat:
        • 0 - fără operand imediat
        • 1 - cu operand imediat
      • bitul [3] - separă instrucțiunile de transfer de date/control de celelalte:
        • 0 - transfer de date/control (MOV, PUSH, CALL etc.) sau care nu salvează rezultatul (CMP, TEST)
        • 1 - instrucțiuni aritmetico-logice cu salvarea rezultatului, salturi condiționate
      • biții [4][5][6] - cod operație
    • d - pentru instrucțiunile cu doi operanzi, folosit pentru a ști care e primul și care e al doilea dintre cele două câmpuri REG și RM din codul instrucțiunii:
      • 0 - RM = RM op REG
      • 1 - REG = REG op RM
    • MOD - modul de calcul al adresei efective (4 moduri - 2 biți)
    • REG - indexul registrului care conține unul dintre operanzi
    • RM - indexul registrului care conține unul dintre operanzi
    InstrucțiuneFuncțieCod RI[0:6]
    INCop = op + 10001 000
    DECop = op - 10001 001
    NEGop = -op0001 010
    NOTop = ~op0001 011
    SHL/SALop = op << 10001 100
    SHRop = op >> 10001 101
    SARop = op >>> 10001 110

    Table: _Instrucțiuni aritmetice-logice cu un operand

    De exemplu, pentru instrucțiunea INC RA grupul este cel al operațiilor cu calcul de adresă efectivă (RI[0] = 0), cu un singur operand (RI[1] = 0), fără operand imediat (RI[2] = 0) și cu salvarea rezultatului (RI[3] = 1).

    Pentru orice procesor, fiecare instrucțiune definită în arhitectura setului său de instrucțiuni, are un anumit cod unic după care este identificată. Atunci când se stochează o instrucțiune care lucrează cu cel puțin un operand, nu este suficient să avem doar codul său (care indică ce acțiune trebuie efectuată), ci trebuie să avem și niște biți care să ne indice de unde luăm operanzii, așa cum este ilustrat și în imaginea de mai jos.

    Dacă MOD = 3 (adresare directă la registru) și instrucțiunea are un singur operand, acesta este pus în RM.

    Se poate observa că în cadrul unora din grupurile de operații au rămas codificări nefolosite pe biții 4:6. Dacă se extinde setul de instrucțiuni cu noi operații (vedeți în curs :!:), atunci codul acestora poate fi unul din cele nefolosite (atâta timp cât se încadrează în acel grup).

    Exemplu de calcul cod operație pentru instrucțiune DEC RB:

    • [0] = 0 - cu calcul de adresă efectivă
    • [1] = 0 - un operand
    • [2] = 0 - fără operand imediat
    • [3] = 1 - operație aritmetică cu salvarea rezultatului
    • [4,5,6] = [0,0,1] - codul dat operației (stabilit de arhitectură)
    • [7] = 0/1 - nu contează, îl putem pune 0 sau 1
    • [8,9] = [1,1] - modul de adresare (directă la registru)
    • [10,11,12] = [0,0,0] - nu folosim REG, deci nu contează ce punem
    • [13,14,15] = [0,0,1] - indexul registrului RB în bancul de registre
    1514131211109876543210
    1000001101001000

    Instrucțiunile care vor fi implementate în acest laborator se regăsesc în tabelul de mai jos. Acestea sunt instrucțiuni aritmetice și logice cu doi operanzi ale căror valori sunt în registrele generale și fie pun un rezultat înapoi în registrul destinație, fie nu stochează rezultatul ci doar setează indicatorii de condiție (CMP și TEST).

    InstrucțiuneFuncțieCod RI[0:6]
    ADDopdst = opdst + opsrc0101000
    ADCopdst = opdst + opsrc + carry0101001
    SUBopdst = opdst - opsrc0101010
    SBBopdst = opdst - opsrc - carry0101011
    ANDopdst = opdst & opsrc0101100
    ORopdst = opdst | opsrc0101101
    XORopdst = opdst ^ opsrc0101110
    CMPopdst - opsrc, fără stocare rezultat, doar setare indicatori0100010
    TESTopdst & opsrc, fără stocare rezultat, doar setare indicatori0100100

    Table: _Instrucțiuni aritmetice-logice cu doi operanzi

    Pentru decodificarea instrucțiunilor din acest laborator trebuie sa identificăm atât grupul instrucțiunilor aritmetice-logice cu doi operanzi, fără operand imediat și care stochează rezultatul (RI0..3 = 0101) cât și cele care nu stochează rezultatul (RI0..3 = 0100).

    Adresarea directă la registru​

    Operanzii se găsesc în registrele specificate de câmpurile REG și RM. Pentru a selecta ordinea operanzilor din aceste două câmpuri, trebuie să ținem cont de valoarea din bitul d. Vom folosi adresarea directă la registru (câmpul mod trebuie să conțină valoarea 2'b11), așa cum se observă în imaginea de mai jos.

    Adresarea directă la registru pentru instrucțiuni cu doi operanzi

    Figure: Adresarea directă la registru pentru instrucțiuni cu doi operanzi

    Instrucțiunea AND RA, RB efectuează ȘI logic între cei doi operanzi și pune rezultatul în registrul destinație (RA). Un exemplu de calcul al codului operației se regăsește mai jos:

    • [0] = 0 - cu calcul de adresă efectivă
    • [1] = 1 - doi operanzi
    • [2] = 0 - fără operand imediat
    • [3] = 1 - operație aritmetică cu salvarea rezultatului
    • [4,5,6] = [1,0,0] - codul dat operației (stabilit de arhitectură)
    • [7] - selectează operandul destinație. Pentru exemplul acesta vom considera că acest bit ia valoarea 1 (destinația va fi registrul RA):
      • 1: REG = REG AND RM
    • [8,9] = [1,1] - modul de adresare (folosim adresarea directă la registru)
    • [10,11,12] = [0,0,0] - indexul registrului RA în bancul de registre
    • [13,14,15] = [0,0,1] - indexul registrului RB în bancul de registre
    1514131211109876543210
    1000001110011010
    - + \ No newline at end of file diff --git a/Laboratoare/8 Calculator Didactic/Unitate de comanda/index.html b/Laboratoare/8 Calculator Didactic/Unitate de comanda/index.html index 65f98a7..020ff54 100644 --- a/Laboratoare/8 Calculator Didactic/Unitate de comanda/index.html +++ b/Laboratoare/8 Calculator Didactic/Unitate de comanda/index.html @@ -4,13 +4,13 @@ Unitate de comanda | Computer Architecture - +
    Skip to main content

    Unitate de comanda

    - + \ No newline at end of file diff --git a/Laboratoare/8 Calculator Didactic/index.html b/Laboratoare/8 Calculator Didactic/index.html index 30babc4..fed1186 100644 --- a/Laboratoare/8 Calculator Didactic/index.html +++ b/Laboratoare/8 Calculator Didactic/index.html @@ -4,13 +4,13 @@ 8 Calculator Didactic | Computer Architecture - +
    Skip to main content

    8 Calculator Didactic

    - + \ No newline at end of file diff --git a/Laboratoare/9 Calculator Didactic/Moduri de adresare/Teorie/index.html b/Laboratoare/9 Calculator Didactic/Moduri de adresare/Teorie/index.html index 6b32f8b..14cfee7 100644 --- a/Laboratoare/9 Calculator Didactic/Moduri de adresare/Teorie/index.html +++ b/Laboratoare/9 Calculator Didactic/Moduri de adresare/Teorie/index.html @@ -4,13 +4,13 @@ Moduri de adresare | Computer Architecture - +
    Skip to main content

    Moduri de adresare

    Modurile de adresare reprezintă modalitatea prin care se poate specifica adresa efectivă a operanzilor. Instrucțiunile calculatorului didactic pot prelucra maxim doi operanzi ce se pot găsi:

    • Ambii în registrele generale RG;
    • Unul în registrele generale RG și altul în memorie;
    • Unul în registrele generale RG și altul în cadrul instrucțiunii respective (numit operand imediat);
    • Unul în memorie și altul imediat.

    Modurile de adresare permise de calculatorul didactic sunt tipice arhitecturilor CISC, fiind derivate din arhitectura standard x86. În total, procesorul permite 11 moduri de adresare, ceea ce îi conferă o foarte bună flexibilitate în programare. Pentru o mai ușoară înțelegere, le vom structura astfel:

    Specificarea operanduluiModuri de adresare
    Operandul nu se găseşte în memorieAdresare directă la registru, Adresare imediată
    Operandul e specificat doar prin deplasamentAdresare directă, Adresare indirectă
    Operandul e specificat doar prin registreAdresare indirectă prin registru, Adresare indirectă prin suma de registre, Adresare indirectă prin suma de registre cu autoincrementare, Adresare indirectă prin suma de registre cu autodecrementare
    Operandul e specificat prin registre și deplasamentAdresare Bazată, Adresare Indexată, Adresare Bazată Indexată

    În continuare vor fi prezentate și discutate aceste moduri de adresare.

    Operandul nu se găsește în memorie​

    1. Adresare directă la registru​

    Operandul se găseşte în RG.

    Exemplu: MOV RA, RB

    Instrucțiunea are ca efect încărcarea în registrul RA a valorii din registrul RB.

    2. Adresare imediată​

    Operandul este specificat în instrucțiune.

    Exemplu: MOV RA, 7

    Instrucțiunea va avea ca efect încarcarea valorii "7" în registrul RA. "7" poartă numele de operand imediat.

    Operandul e specificat doar prin deplasament​

    3. Adresare directă​

    Adresa efectivă este specificată în instrucțiune.

    Exemplu: MOV RA, [12]

    Instrucțiunea va încărca valorea aflată în memorie la adresa "12" în registrul RA. "12" poarta numele de deplasament.

    4. Adresare indirectă​

    Adresa efectivă se citește din memorie, din locația a cărei adresă este specificată în instrucțiune.

    Exemplu: MOV RA, [[12]]

    Instrucțiunea are ca efect încărcarea valorii aflată la adresa ce se găsește în memorie la adresa "12". Acest mod de adresare seamană foarte bine cu pointerii din C. La adresa "12" se găsește pointer-ul către operand.

    Operandul e specificat doar prin registre​

    5. Adresare indirectă prin registru​

    Adresa efectivă se găsește în unul din registrele XA, XB, BA, BB.

    Exemplu: MOV RA, [BA]

    Instrucțiunea va încărca în RA valoarea aflată în memorie la adresa conținută în BA.

    6. Adresare indirectă prin sumă de registre​

    Adresa efectivă se obține ca sumă a conținutului unui registru de bază cu conținutul unui registru index.

    Exemplu: MOV RA, [BA][XA] sau MOV RA, [BA+XA]

    Instrucțiunile încarcă în RA valoarea aflată în memorie la adresa obținută prin adunarea conținutului registrelor BA și XA. BA, BB poartă numele de registre de bază, iar XA, XB poartă numele de registre index. Întotdeauna suma se va face între un registru bază și unul index.

    7. Adresare indirectă prin sumă de registre cu autoincrementare​

    Față de modul precedent de adresare apare deosebirea că registrele index se incrementează după generarea adresei efective. Incrementarea registrului index (XA sau XB) are deci loc după participarea la calculul adresei efective.

    Exemplu: MOV RA, [BA][XA+] sau MOV RA, [BA+XA+]

    Aceste instrucțiuni sunt echivalente cu:

    MOV RA, [BA][XA]
    INC XA

    8. Adresare indirectă prin sumă de registre cu autodecrementare​

    Adresa efectivă se obține prin suma unui registru de bază cu continutul registrului XA. Înaintea generării adresei, registrul XA este decrementat.

    Exemplu: MOV RA, [BA][XA-] sau MOV RA, [BA+XA-]

    Aceste instrucțiuni sunt echivalente cu:

    DEC XA
    MOV RA, [BA][XA]

    Observații: Motivul pentru care XB nu poate fi utilizat în acest mod de adresare nu este unul logic, ci unul tehnic: biții din codul de instrucțiune nu au fost suficienți pentru a se putea codifica și acest mod.

    Operandul e specificat prin registre și deplasament​

    9. Adresare bazată​

    Adresa efectivă se obține prin adunarea unui registru de bază cu un deplasament.

    Exemplu: MOV RA, [BA]+7 sau MOV RA, [BA+7]

    Instrucțiunea încarcă în registrul RA valoarea aflată în memorie la adresa rezultată în urma adunării conținutului registrului de bază cu deplasamentul (7).

    10. Adresare indexată​

    Adresa efectivă se obține prin adunarea unui registru index cu un deplasament.

    Exemplu: MOV RA, [XA]+7 sau MOV RA, [XA+7]

    Instrucțiunea încarcă în registrul RA valoarea aflată în memorie la adresa rezultată în urma adunării conținutului registrului de index cu deplasamentul (7).

    11. Adresare bazată indexată​

    Adresa efectivă se obține prin adunarea unui registru de bază cu un registru index și cu un deplasament.

    Exemplu: MOV RA, [BA][XA]+7 sau MOV RA, [BA+XA+7]

    Instrucțiunea încarcă în registrul RA valoarea aflată în memorie la adresa rezultată în urma adunării conținutului registrului de bază (BA) cu registrul index (XA) și cu deplasamentul (7).

    Calculatorul didactic​

    Procesorul calculatorului didactic suportă mai multe moduri de adresare a operanzilor. Până acum am tratat doar cazul operanzilor aflați în registre (adresare directă la registru), identificat prin câmpul MOD având valoarea 11. Cu acest mod de adresare suntem însă limitați la a lucra numai cu cele 8 registre generale. Pentru a putea lucra și cu date aflate în memoria RAM, procesorul calculatorului didactic oferă o serie de alte moduri de încărcare a operanzilor.

    Încărcarea unui operand din memoria RAM necesită determinarea adresei la care se află stocat acel operand. Aceasta poate fi stocată direct în instrucțiune, cum se întâmplă în cazul adresării directe, unde instrucțiunea este formată din 2 cuvinte (pe 16 biți), iar al doilea cuvânt conține valoarea adresei (numită și deplasament), sau poate fi calculată folosind diferite combinații de registre cu/fără deplasament. Calculul se face prin adunarea valorilor curente ale unor registre (nu toate combinațiile sunt suportate) și folosirea valorii rezultate ca o adresă pentru memorie.

    Adresarea indirectă prin registru​

    Adresa efectivă se găsește într-unul din registrele XA, XB, BA sau BB. Modul de determinare a acesteia este prezentat în imaginea de mai jos.

    Ex: mov RA, [BA]

    Adresare indirectă prin registru

    Figure: Adresare indirectă prin registru

    Adresarea indirectă prin sumă de registre​

    Adresa efectivă se obține prin sumarea conținutului unui registru de bază (BA sau BB) cu conținutul unui registru index (XA sau XB). Modul de determinare a acesteia este prezentat în imaginea de mai jos.

    Ex: mov RA, [BA + XA]

    Adresare indirectă prin sumă de registre

    Figure: Adresare indirectă prin sumă de registre

    Implementare​

    Automatul care trebuie implementat în UC este descris în diagrama de stări din figura de mai jos.

    Diagrama de stări a unității de comandă

    Figure: Diagrama de stări a unității de comandă

    După cum puteți observa, la stările deja implementate în laboratoarele anterioare au fost adăugate o serie de stări noi, necesare pentru adresarea indirectă prin registru sau sumă de registre. În cadrul acestui laborator va trebui să implementați aceste noi stări și să completați condițiile corecte pentru decodificarea noilor moduri de adresare.

    TODO: schimbat total cu cram.data

    Memoria calculatorului didactic este implementată cu ajutorul unui IP Core Xilinx de tipul Block Memory. Parametrii unui core sunt stocați într-un fișier .xco. Acest fișier este folosit de utilitarul de generare a IP Core-urilor pentru a genera o instanță a core-ului selectat. Core-ul de tip Block Memory oferă o serie de parametri care pot fi configurați, precum dimensiunea cuvântului, numărul de cuvinte și semnalele disponibile. Block Memory oferă și posibilitatea inițializării memoriei în momentul generării. Conținutul memoriei poate fi specificat într-un fișier .coe referențiat apoi de fișierul .xco. În figura de mai jos puteți observa formatul fișierul .coe. Valorile din fișier sunt mapate în memoria generată începând de la adresa 0.

    Fișierul ram.coe

    Figure: Fișierul ram.coe

    Conținutul inițial al memoriei calculatorului didactic se găsește în cadrul acestui fișier. După fiecare modificare a fișierului .coe, memoria care folosește acel fișier trebuie regenerată. În cazul nostru, după modificarea fișierului ram.coe trebuie regenerat modulul ram pentru ca modificările să aibă efect. Pentru aceasta, se selectează din fereastra Sources modulul ram, iar din fereastra Processes se inițiază regenerarea, cu opțiunea Regenerate Core.

    - + \ No newline at end of file diff --git a/Laboratoare/9 Calculator Didactic/Moduri de adresare/index.html b/Laboratoare/9 Calculator Didactic/Moduri de adresare/index.html index 2bc52e7..570fe81 100644 --- a/Laboratoare/9 Calculator Didactic/Moduri de adresare/index.html +++ b/Laboratoare/9 Calculator Didactic/Moduri de adresare/index.html @@ -4,13 +4,13 @@ Moduri de adresare | Computer Architecture - +
    Skip to main content

    Moduri de adresare

    - + \ No newline at end of file diff --git a/Laboratoare/9 Calculator Didactic/index.html b/Laboratoare/9 Calculator Didactic/index.html index 7055f08..e4096e6 100644 --- a/Laboratoare/9 Calculator Didactic/index.html +++ b/Laboratoare/9 Calculator Didactic/index.html @@ -4,13 +4,13 @@ 9 Calculator Didactic | Computer Architecture - +
    Skip to main content

    9 Calculator Didactic

    - + \ No newline at end of file diff --git a/Laboratoare/index.html b/Laboratoare/index.html index 38459f3..437ee2a 100644 --- a/Laboratoare/index.html +++ b/Laboratoare/index.html @@ -4,13 +4,13 @@ Laboratoare | Computer Architecture - +
    Skip to main content

    Laboratoare

    - + \ No newline at end of file diff --git a/Tutoriale/Creare proiect Vivado/index.html b/Tutoriale/Creare proiect Vivado/index.html index c0734d8..aa821b6 100644 --- a/Tutoriale/Creare proiect Vivado/index.html +++ b/Tutoriale/Creare proiect Vivado/index.html @@ -4,7 +4,7 @@ Tutorial creare proiect Vivado | Computer Architecture - + @@ -20,7 +20,7 @@ exemplu
  • La acest pas puteți defini numele modulului și porturile acestuia: exemplu
  • În final, în Vivado veți putea vizualiza proiectul astfel astfel.

    • În stânga ecranului putem vedea pașii de simulare, sintetizare, implementare și generare a bitstream-ului ce va fi folosit pentru configurarea interna a FPGA-ului.

    Proiect Vivado

    Dacă aveți sugestii de îmbunătățire a acestei pagini vă rog să trimiteți sugestiile pe mail la dosarudaniel@gmail.com.

    - + \ No newline at end of file diff --git a/Tutoriale/Docker/Linux/index.html b/Tutoriale/Docker/Linux/index.html index 61a3a1e..444919c 100644 --- a/Tutoriale/Docker/Linux/index.html +++ b/Tutoriale/Docker/Linux/index.html @@ -4,7 +4,7 @@ Utilizare imagine Docker Linux | Computer Architecture - + @@ -20,7 +20,7 @@ S-ar putea să fie nevoie și de un unset XDG_SEAT în cazul în care nu toate inputurile tastaturii sau mouse-ului sunt luate în considerare

    Mai multe detalii aici

    Am ecran alb când deschid cu Wayland​

    Scrie în shell, înainte să execuți Vivado, export _JAVA_AWT_WM_NONREPARENTING=1.
    O altă variantă este să decommentezi linia din Dockerfile care dă echo la această linie în .bashrc.

    Stuck la deschiderea hardware managerului​

    În terminalul din VSCode, scrie hw_server. Dacă o să funcționeze, o să apară un output sub următorul format:

    ****** Xilinx hw_server v2022.1
      **** Build date : Apr 18 2022 at 16:10:30
        ** Copyright 1986-2022 Xilinx, Inc. All Rights Reserved.

    INFO: hw_server application started
    INFO: Use Ctrl-C to exit hw_server application

    INFO: To connect to this hw_server instance use url: TCP:ba86b6047b8c:3121

    Copiază ce este între TCP: și :3121 și folosește-l ca 'url' la conexiunea remote.

    - + \ No newline at end of file diff --git a/Tutoriale/Docker/MacOS/index.html b/Tutoriale/Docker/MacOS/index.html index 5d51d32..e47526c 100644 --- a/Tutoriale/Docker/MacOS/index.html +++ b/Tutoriale/Docker/MacOS/index.html @@ -4,13 +4,13 @@ Utilizare imagine docker MacOS | Computer Architecture - +
    Skip to main content

    Utilizare imagine docker MacOS

    Cerințe necesare​

    Docker Desktop​

    Instalare Docker Desktop.

    Instalre XQuartz​

    Instalare XQuartz

    Visual Studio Code​

    Descărcați și instalați Visual Studio Code

    Clonați repo-ul materiei​

    git clone https://github.com/cs-pub-ro/computer-architecture.git

    Rulare​

    Porniți XQuartz​

    1. Deschideți Applications > Utilities > XQuartz

    Opțiunea 1 din Visual Studio Code​

    1. Deschideți directorul repo-ului în Visual Studio Code.
    code computer-architecture

    1. Instalați extensia Dev Containers.

    2. După veți avea opțiunea "Dev Containers: Reopen in container" (CTRL+SHIFT+P).

    Opțiunea 2 prin docker​

    1. Descărcați imaginea cu docker
    docker pull gitlab.cs.pub.ro:5050/ac/ac-public/vivado-slim:1.0.0
    1. Rulați un container cu imaginea
    docker run --rm -it -v /dev:/dev gitlab.cs.pub.ro:5050/ac/ac-public/vivado-slim:1.0.0 /bin/bash
    1. Rulați vivado din imagine
    vivado
    - + \ No newline at end of file diff --git a/Tutoriale/Docker/Windows/index.html b/Tutoriale/Docker/Windows/index.html index f8f3997..f07bdeb 100644 --- a/Tutoriale/Docker/Windows/index.html +++ b/Tutoriale/Docker/Windows/index.html @@ -4,13 +4,13 @@ Utilizare imagine docker Windows | Computer Architecture - +
    Skip to main content

    Utilizare imagine docker Windows

    Cerințe necesare​

    WSL​

    1. Deschideți meniul Start și tastați "Windows features" în bara de căutare și faceți clic pe "Turn Windows Features On or Off".

    2. Bifați casetele "Windows Subsystem for Linux" și "Virtual Machine Platform" și apăsați butonul "OK".

    3. Când operațiunea este completă, vi se va cere să reporniți computerul.

    4. Instalați distribuția dorită din command prompt:

    wsl --install -d Ubuntu-22.04

    Alt tutorial Ubuntu

    Docker Desktop​

    Instalare Docker Desktop.

    Instalre XLaunch​

    1. Descărcați Xming X Server - Public Domain Releases

    installxlaunch1

    1. Deschideți installer-ul și apăsați butonul "Next".

    installxlaunch2

    1. Apăsați butonul "Next".

    installxlaunch3

    1. Apăsați butonul "Next".

    installxlaunch4

    1. Apăsați butonul "Next".

    installxlaunch5

    1. Selectați "Create a desktop icon for XLaunch" și apăsați butonul "Next".

    installxlaunch6

    1. Apăsați butonul "Install".

    installxlaunch7

    1. Apăsați butonul "Finish".

    installxlaunch8

    Visual Studio Code​

    Descărcați și instalați Visual Studio Code

    Clonați repo-ul materiei​

    git clone https://github.com/cs-pub-ro/computer-architecture.git

    Rulare​

    Porniți XLaunch​

    1. Deschideți XLaunch (Desktop sau Start Menu)

    2. Selectați opțiunile pentru Disaply și apăsați butonul "Next".

    runxlaunch1

    1. Selectați "Start no client" și apăsați butonul "Next".

    runxlaunch2

    1. Selectați "No access control" și apăsați butonul "Next".

    runxlaunch3

    1. Apăsați butonul "Finish".

    runxlaunch4

    Opțiunea 1 din Visual Studio Code​

    1. Deschideți directorul repo-ului în Visual Studio Code.
    code computer-architecture

    1. Instalați extensia Dev Containers.

    2. După veți avea opțiunea "Dev Containers: Reopen in container" (CTRL+SHIFT+P).

    Opțiunea 2 prin docker​

    1. Descărcați imaginea cu docker
    docker pull gitlab.cs.pub.ro:5050/ac/ac-public/vivado-slim:1.0.0
    1. Rulați un container cu imaginea
    docker run --rm -it -v /dev:/dev gitlab.cs.pub.ro:5050/ac/ac-public/vivado-slim:1.0.0 /bin/bash
    1. Rulați vivado din imagine
    vivado

    Troubleshooting​

    Vivado nu vede seriala catre FPGA (laptop)​

    Urmăriți tutorialul până la finalul sesiunii "Attach the device to wsl2" usbipd

    - + \ No newline at end of file diff --git a/Tutoriale/Docker/index.html b/Tutoriale/Docker/index.html index c2ce4f2..4a2406e 100644 --- a/Tutoriale/Docker/index.html +++ b/Tutoriale/Docker/index.html @@ -4,13 +4,13 @@ Docker | Computer Architecture - +
    Skip to main content

    Docker

    - + \ No newline at end of file diff --git a/Tutoriale/Instalare Vivado/index.html b/Tutoriale/Instalare Vivado/index.html index 7bd27e8..23ffcaf 100644 --- a/Tutoriale/Instalare Vivado/index.html +++ b/Tutoriale/Instalare Vivado/index.html @@ -4,7 +4,7 @@ Instalare Vivado | Computer Architecture - + @@ -28,7 +28,7 @@ ManageLicense2

  • Apăsăm pe Copy License și navigăm către directorul unde am descărcat la punctul 16 licența. O selectăm, iar apoi apăsăm pe Open pentru a o încărca (exemplu). GetLicense

  • În final, pentru a verifica încărcarea corectă a licenței, alegem tot din meniul vertical, opțiunea View License Status și ar trebui să avem o pagină similară cu aceasta. FinishLicense

  • Pentru Linux, e necesară și instalarea separată a Cable Drivers - detalii aici.

    • Dacă aveți sugestii de îmbunătățire a acestei pagini vă rog să trimiteți sugestiile pe mail la dosarudaniel@gmail.com.

    Lista colaboratorilor:

    - + \ No newline at end of file diff --git a/Tutoriale/Programare FPGA Vivado/index.html b/Tutoriale/Programare FPGA Vivado/index.html index 89e9116..8b2d43e 100644 --- a/Tutoriale/Programare FPGA Vivado/index.html +++ b/Tutoriale/Programare FPGA Vivado/index.html @@ -4,7 +4,7 @@ Programarea FPGA-ului în Vivado | Computer Architecture - + @@ -27,7 +27,7 @@ Program device
  • Apoi să apăsăm Program dacă avem deja locația fișierului .bit la Bitstream file. Program
  • În final ar trebui să avem un mesaj în consolă și ledul "Done" aprins pe plăcuță. Consolă
  • Dacă toți pașii au fost parcurși în mod corespunzător, ledul H17 ar trebui să se aprindă cât timp butonul N17 este apăsat.

    • Dacă aveți sugestii de îmbunătățire a acestei pagini vă rog să trimiteți sugestiile pe mail la dosarudaniel@gmail.com. Sugestiile bune vor fi recompensate cu puncte bonus.

    - + \ No newline at end of file diff --git a/Tutoriale/Rulare exemple practice/index.html b/Tutoriale/Rulare exemple practice/index.html index b798a97..775ad16 100644 --- a/Tutoriale/Rulare exemple practice/index.html +++ b/Tutoriale/Rulare exemple practice/index.html @@ -4,13 +4,13 @@ Rulare exemple practice Verilog | Computer Architecture - +
    Skip to main content

    Rulare exemple practice Verilog

    Exemple practice necesită aplicația Vivado 2022.1 (urmărește tutorialul de instalare sau cel pentru docker) și utlitarul make. Directoarele au o structură asemănătoare (eq. alu):

    • director tcl_files unde sunt prezente scripturi ajutătoare
      • build.tcl pentru crearea proiectului .xpr
      • run.tcl pentru rularea simulării și crearea fișierului de unde test.vcd
      • simulation.tcl pentru vizionarea rezultatului simulării în interfață grafică.
    • test_*.v fișierul ce conține detaliile pentru simulare
    • *.v fișiere verilog necesare implementării
    • *.xdc fișierul ce conține constrângerile de pini pentru FPGA folosit în cadrul laboratorului (Nexys 4 Arty-A7-100T)
    • Makefile fișierul Makefile ce conține rețetele pentru principale comenzi

    Comenzile prezente în Makefile sunt:

    • make build crează proiectul Vivado necesar.
    • make run după crearea proiectului putem rula simularea
    • make simulation după rularea simulării putem încărca grafic simularea.
    • make vivado deschiderea proeictului Vivado 2022.1 pentru modificări sau încărcarea pe FPGA conform ghidului Programare Vivado FPGA.
    • make clean ștergerea fișierelor generate de comenzile anterioare

    Dacă lucrăm în Visual Studio Code sau alt editor text decât Vivado după fiecare modificare pentru a vedea rezultate noi va trebuie să rulăm make clean && make build.

    - + \ No newline at end of file diff --git a/Tutoriale/Simulare Vivado/index.html b/Tutoriale/Simulare Vivado/index.html index df58b72..2fe31b3 100644 --- a/Tutoriale/Simulare Vivado/index.html +++ b/Tutoriale/Simulare Vivado/index.html @@ -4,7 +4,7 @@ Simulare modul în Vivado | Computer Architecture - + @@ -27,7 +27,7 @@ reîncărca
  • Rezultatul final se poate vedea dacă apăsăm pe Zoom Fit. Zoom Fit.
  • În final putem verifica vizual dacă semnalele au valorile pe care le așteptăm: exemplu corect.

    • Dacă aveți sugestii de îmbunătățire a acestei pagini vă rog să trimiteți sugestiile pe mail la dosarudaniel@gmail.com. Studenții implicați vor fi recomensați cu puncte bonus.

    - + \ No newline at end of file diff --git a/Tutoriale/VPL/index.html b/Tutoriale/VPL/index.html index 555d7d0..aa882c6 100644 --- a/Tutoriale/VPL/index.html +++ b/Tutoriale/VPL/index.html @@ -4,13 +4,13 @@ Moodle VPL | Computer Architecture - +
    Skip to main content

    Moodle VPL

    1. Din cadrul cursului vom selecta "SIMULARE VPL"

    VPL1

    1. Veți avea următoarea fereastră care va conține descrierea exercițiului și fișierele pe care le puteți modifica. Pentru a le edita apăsați butonul "EDIT".

    VPL2

    1. În cadrul IDE-ului VPL veți avea un tab cu fiecare fișier (mux.v, test_mux.v), punctajul în dreapta, rezultatele compilării sau evaluării.

    VPL3

    1. Puteți modifica fișierul "mux.v". Atât timp cât fișierele nu sunt salvate veți avea o stea în dreptul numelui fișierului. Pentru a salva apăsați butonul "Save".

    VPL4

    1. O dată salvat fișierul steaua va dispărea. Acum puteți apăsa pe butonul "Run" pentru a vedea enunțul.

    VPL5

    1. Se va porni o consolă ca în imaginea următoare. Veți avea detalii despre implementarea pe care o aveți de făcut și rezultatele rulării modului nostru de test/simulare.

    VPL6

    1. Pentru a evalua soluția voastră puteți apăsa butonul "Evaluate". Nota va fi modificată în dreapta și vom avea descrierea implementării și primul test eșuat.

    VPL7

    1. Pentru a vedea mai bine detaliile testului puteți modifica mărimea ferestrelor.

    VPL8

    1. Daca doriți să rulați testele voastre pentru a face debug, puteți modifica fișierul "test_mux.v".

    VPL9

    1. Folosim butonul "Run" și vom vedea rezultatele simulării.

    VPL10

    - + \ No newline at end of file diff --git a/Tutoriale/index.html b/Tutoriale/index.html index 1da0f77..8b6b45b 100644 --- a/Tutoriale/index.html +++ b/Tutoriale/index.html @@ -4,13 +4,13 @@ Tutoriale | Computer Architecture - +
    Skip to main content

    Tutoriale

    - + \ No newline at end of file diff --git a/assets/js/d2ae71ae.549845cf.js b/assets/js/d2ae71ae.5ed938df.js similarity index 77% rename from assets/js/d2ae71ae.549845cf.js rename to assets/js/d2ae71ae.5ed938df.js index a18a78c..118eb90 100644 --- a/assets/js/d2ae71ae.549845cf.js +++ b/assets/js/d2ae71ae.5ed938df.js @@ -1 +1 @@ -"use strict";(self.webpackChunkcomputer_architecture=self.webpackChunkcomputer_architecture||[]).push([[3533],{5680:(e,t,a)=>{a.d(t,{xA:()=>c,yg:()=>g});var i=a(6540);function r(e,t,a){return t in e?Object.defineProperty(e,t,{value:a,enumerable:!0,configurable:!0,writable:!0}):e[t]=a,e}function n(e,t){var a=Object.keys(e);if(Object.getOwnPropertySymbols){var i=Object.getOwnPropertySymbols(e);t&&(i=i.filter((function(t){return Object.getOwnPropertyDescriptor(e,t).enumerable}))),a.push.apply(a,i)}return a}function l(e){for(var t=1;t=0||(r[a]=e[a]);return r}(e,t);if(Object.getOwnPropertySymbols){var n=Object.getOwnPropertySymbols(e);for(i=0;i=0||Object.prototype.propertyIsEnumerable.call(e,a)&&(r[a]=e[a])}return r}var o=i.createContext({}),s=function(e){var t=i.useContext(o),a=t;return e&&(a="function"==typeof e?e(t):l(l({},t),e)),a},c=function(e){var t=s(e.components);return i.createElement(o.Provider,{value:t},e.children)},p="mdxType",m={inlineCode:"code",wrapper:function(e){var t=e.children;return i.createElement(i.Fragment,{},t)}},d=i.forwardRef((function(e,t){var a=e.components,r=e.mdxType,n=e.originalType,o=e.parentName,c=u(e,["components","mdxType","originalType","parentName"]),p=s(a),d=r,g=p["".concat(o,".").concat(d)]||p[d]||m[d]||n;return a?i.createElement(g,l(l({ref:t},c),{},{components:a})):i.createElement(g,l({ref:t},c))}));function g(e,t){var a=arguments,r=t&&t.mdxType;if("string"==typeof e||r){var n=a.length,l=new Array(n);l[0]=d;var u={};for(var o in t)hasOwnProperty.call(t,o)&&(u[o]=t[o]);u.originalType=e,u[p]="string"==typeof e?e:r,l[1]=u;for(var s=2;s{a.r(t),a.d(t,{assets:()=>o,contentTitle:()=>l,default:()=>m,frontMatter:()=>n,metadata:()=>u,toc:()=>s});var i=a(8168),r=(a(6540),a(5680));const n={},l="FLAG-RAM",u={unversionedId:"Evaluare/Test Circuite Secven\u021biale/Flag RAM/README",id:"Evaluare/Test Circuite Secven\u021biale/Flag RAM/README",title:"FLAG-RAM",description:'Implementati un modul ce va contine o memorie RAM (4 biti de adresare si 4 biti de date) si un registru de flag-uri ce va contine informatii despre ultimul cuvant citit din memoria RAM. Modulul ram este dat si prezent in fisierul "ram.v" (NU MODIFICATI, DOAR INSTANTIATI IN MODULUL VOSTRU). O implementare de registrul este prezenta in fisierul "register.v" (Folosirea lui este optionala).',source:"@site/docs/Evaluare/Test Circuite Secven\u021biale/Flag RAM/README.md",sourceDirName:"Evaluare/Test Circuite Secven\u021biale/Flag RAM",slug:"/Evaluare/Test Circuite Secven\u021biale/Flag RAM/",permalink:"/computer-architecture/Evaluare/Test Circuite Secven\u021biale/Flag RAM/",draft:!1,tags:[],version:"current",frontMatter:{},sidebar:"sidebar",previous:{title:"Operation Register",permalink:"/computer-architecture/Evaluare/Test Circuite Secven\u021biale/Operation Register/"},next:{title:"Teme",permalink:"/computer-architecture/Evaluare/Teme/"}},o={},s=[],c={toc:s},p="wrapper";function m(e){let{components:t,...a}=e;return(0,r.yg)(p,(0,i.A)({},c,a,{components:t,mdxType:"MDXLayout"}),(0,r.yg)("h1",{id:"flag-ram"},"FLAG-RAM"),(0,r.yg)("p",null,'Implementati un modul ce va contine o memorie RAM (4 biti de adresare si 4 biti de date) si un registru de flag-uri ce va contine informatii despre ultimul cuvant citit din memoria RAM. Modulul ram este dat si prezent in fisierul "ram.v" (NU MODIFICATI, DOAR INSTANTIATI IN MODULUL VOSTRU). O implementare de registrul este prezenta in fisierul "register.v" (Folosirea lui este optionala).'),(0,r.yg)("p",null,"Modulul de implementat are urmatoarele intrari:"),(0,r.yg)("ul",null,(0,r.yg)("li",{parentName:"ul"},"i_w_clk - ceas"),(0,r.yg)("li",{parentName:"ul"},"i_w_address - adresa de memorie ram (4 biti)"),(0,r.yg)("li",{parentName:"ul"},"i_w_data - data de intrare (4 biti)"),(0,r.yg)("li",{parentName:"ul"},"i_w_we - daca se scrie in RAM"),(0,r.yg)("li",{parentName:"ul"},"i_w_oe - daca se afiseaza din RAM"),(0,r.yg)("li",{parentName:"ul"},"i_w_flags_out - daca se afiseaza valorea registrului flag (activ pozitiv 1'b1)")),(0,r.yg)("p",null,"Ie\u0219irea modulului este:"),(0,r.yg)("ul",null,(0,r.yg)("li",{parentName:"ul"},"o_w_out - datele citite din RAM sau valoarea registrului flag (4 biti)")),(0,r.yg)("p",null,"Ordinea de prioritate a opera\u021bilor este (i_w_we > i_w_oe > i_w_flags_out)."),(0,r.yg)("p",null,'Registrul flag va avea 4 biti si va avea de implementat 4 flag-uri. Veti afla flag-urile de implementat si pozitia lor dupa apasarea butonului "evaluate" din VPL.'),(0,r.yg)("p",null,"Flag-uri posibile:"),(0,r.yg)("ul",null,(0,r.yg)("li",{parentName:"ul"},"Z - if all bits are unset"),(0,r.yg)("li",{parentName:"ul"},"S - if the sign bit is set (MSB)"),(0,r.yg)("li",{parentName:"ul"},"E - if it has an even number of bits set"),(0,r.yg)("li",{parentName:"ul"},"O - if it has an odd number of bits set"),(0,r.yg)("li",{parentName:"ul"},"C2 - if the bit on the position 2 is clear"),(0,r.yg)("li",{parentName:"ul"},"S2 - if the bit on the position 2 is set"),(0,r.yg)("li",{parentName:"ul"},"G4 - if the data value is greater than 4"),(0,r.yg)("li",{parentName:"ul"},"L4 - if the data value is lower than 4"),(0,r.yg)("li",{parentName:"ul"},"POW - if the data value is a power of 2 (1,2,4,8)"),(0,r.yg)("li",{parentName:"ul"},"SMAX - if the data value is the maximum signed value"),(0,r.yg)("li",{parentName:"ul"},"SMIN - if the data value is the minimum signed value"),(0,r.yg)("li",{parentName:"ul"},"MAX - if the data value is the maximum unsigned value"),(0,r.yg)("li",{parentName:"ul"},"PAL - if the data value is a binary palindrome (0110 -1, 1010-0)"),(0,r.yg)("li",{parentName:"ul"},"SB2 - if there are at least 2 consecutive bits set (1100-1, 0101-0)")))}m.isMDXComponent=!0}}]); \ No newline at end of file +"use strict";(self.webpackChunkcomputer_architecture=self.webpackChunkcomputer_architecture||[]).push([[3533],{5680:(e,t,a)=>{a.d(t,{xA:()=>c,yg:()=>f});var i=a(6540);function r(e,t,a){return t in e?Object.defineProperty(e,t,{value:a,enumerable:!0,configurable:!0,writable:!0}):e[t]=a,e}function n(e,t){var a=Object.keys(e);if(Object.getOwnPropertySymbols){var i=Object.getOwnPropertySymbols(e);t&&(i=i.filter((function(t){return Object.getOwnPropertyDescriptor(e,t).enumerable}))),a.push.apply(a,i)}return a}function l(e){for(var t=1;t=0||(r[a]=e[a]);return r}(e,t);if(Object.getOwnPropertySymbols){var n=Object.getOwnPropertySymbols(e);for(i=0;i=0||Object.prototype.propertyIsEnumerable.call(e,a)&&(r[a]=e[a])}return r}var o=i.createContext({}),s=function(e){var t=i.useContext(o),a=t;return e&&(a="function"==typeof e?e(t):l(l({},t),e)),a},c=function(e){var t=s(e.components);return i.createElement(o.Provider,{value:t},e.children)},p="mdxType",m={inlineCode:"code",wrapper:function(e){var t=e.children;return i.createElement(i.Fragment,{},t)}},g=i.forwardRef((function(e,t){var a=e.components,r=e.mdxType,n=e.originalType,o=e.parentName,c=u(e,["components","mdxType","originalType","parentName"]),p=s(a),g=r,f=p["".concat(o,".").concat(g)]||p[g]||m[g]||n;return a?i.createElement(f,l(l({ref:t},c),{},{components:a})):i.createElement(f,l({ref:t},c))}));function f(e,t){var a=arguments,r=t&&t.mdxType;if("string"==typeof e||r){var n=a.length,l=new Array(n);l[0]=g;var u={};for(var o in t)hasOwnProperty.call(t,o)&&(u[o]=t[o]);u.originalType=e,u[p]="string"==typeof e?e:r,l[1]=u;for(var s=2;s{a.r(t),a.d(t,{assets:()=>o,contentTitle:()=>l,default:()=>m,frontMatter:()=>n,metadata:()=>u,toc:()=>s});var i=a(8168),r=(a(6540),a(5680));const n={},l="FLAG-RAM",u={unversionedId:"Evaluare/Test Circuite Secven\u021biale/Flag RAM/README",id:"Evaluare/Test Circuite Secven\u021biale/Flag RAM/README",title:"FLAG-RAM",description:'Implementati un modul ce va contine o memorie RAM (4 biti de adresare si 4 biti de date) si un registru de flag-uri ce va contine informatii despre ultimul cuvant citit din memoria RAM. Modulul ram este dat si prezent in fisierul "ram.v" (NU MODIFICATI, DOAR INSTANTIATI IN MODULUL VOSTRU). O implementare de registrul este prezenta in fisierul "register.v" (Folosirea lui este optionala).',source:"@site/docs/Evaluare/Test Circuite Secven\u021biale/Flag RAM/README.md",sourceDirName:"Evaluare/Test Circuite Secven\u021biale/Flag RAM",slug:"/Evaluare/Test Circuite Secven\u021biale/Flag RAM/",permalink:"/computer-architecture/Evaluare/Test Circuite Secven\u021biale/Flag RAM/",draft:!1,tags:[],version:"current",frontMatter:{},sidebar:"sidebar",previous:{title:"Operation Register",permalink:"/computer-architecture/Evaluare/Test Circuite Secven\u021biale/Operation Register/"},next:{title:"Teme",permalink:"/computer-architecture/Evaluare/Teme/"}},o={},s=[],c={toc:s},p="wrapper";function m(e){let{components:t,...a}=e;return(0,r.yg)(p,(0,i.A)({},c,a,{components:t,mdxType:"MDXLayout"}),(0,r.yg)("h1",{id:"flag-ram"},"FLAG-RAM"),(0,r.yg)("p",null,'Implementati un modul ce va contine o memorie RAM (4 biti de adresare si 4 biti de date) si un registru de flag-uri ce va contine informatii despre ultimul cuvant citit din memoria RAM. Modulul ram este dat si prezent in fisierul "ram.v" (NU MODIFICATI, DOAR INSTANTIATI IN MODULUL VOSTRU). O implementare de registrul este prezenta in fisierul "register.v" (Folosirea lui este optionala).'),(0,r.yg)("p",null,"Modulul de implementat are urmatoarele intrari:"),(0,r.yg)("ul",null,(0,r.yg)("li",{parentName:"ul"},"i_w_clk - ceas"),(0,r.yg)("li",{parentName:"ul"},"i_w_address - adresa de memorie ram (4 biti)"),(0,r.yg)("li",{parentName:"ul"},"i_w_data - data de intrare (4 biti)"),(0,r.yg)("li",{parentName:"ul"},"i_w_we - daca se scrie in RAM"),(0,r.yg)("li",{parentName:"ul"},"i_w_oe - daca se afiseaza din RAM"),(0,r.yg)("li",{parentName:"ul"},"i_w_flags_out - daca se afiseaza valorea registrului flag (activ pozitiv 1'b1)")),(0,r.yg)("p",null,"Ie\u0219irea modulului este:"),(0,r.yg)("ul",null,(0,r.yg)("li",{parentName:"ul"},"o_w_out - datele citite din RAM sau valoarea registrului flag (4 biti)")),(0,r.yg)("p",null,"Ordinea de prioritate a opera\u021bilor este (i_w_we > i_w_oe > i_w_flags_out)."),(0,r.yg)("p",null,'Registrul flag va avea 4 biti si va avea de implementat 4 flag-uri. Veti afla flag-urile de implementat si pozitia lor dupa apasarea butonului "evaluate" din VPL.'),(0,r.yg)("p",null,"Flag-uri posibile:"),(0,r.yg)("ul",null,(0,r.yg)("li",{parentName:"ul"},"Z - if all bits are unset"),(0,r.yg)("li",{parentName:"ul"},"S - if the sign bit is set (MSB)"),(0,r.yg)("li",{parentName:"ul"},"E - if it has an even number of bits set"),(0,r.yg)("li",{parentName:"ul"},"O - if it has an odd number of bits set"),(0,r.yg)("li",{parentName:"ul"},"C2 - if the bit on the position 2 (counting starts from 0, from right to left) is clear (4'b0101 - 0, 4'b1010 - 1)"),(0,r.yg)("li",{parentName:"ul"},"S2 - if the bit on the position 2 (counting starts from 0, from right to left) is set (4'b0101 - 1, 4'b1010 - 0)"),(0,r.yg)("li",{parentName:"ul"},"G4 - if the data value is greater than 4"),(0,r.yg)("li",{parentName:"ul"},"L4 - if the data value is lower than 4"),(0,r.yg)("li",{parentName:"ul"},"POW - if the data value is a power of 2 (1,2,4,8)"),(0,r.yg)("li",{parentName:"ul"},"SMAX - if the data value is the maximum signed value"),(0,r.yg)("li",{parentName:"ul"},"SMIN - if the data value is the minimum signed value"),(0,r.yg)("li",{parentName:"ul"},"MAX - if the data value is the maximum unsigned value"),(0,r.yg)("li",{parentName:"ul"},"PAL - if the data value is a binary palindrome (0110 -1, 1010-0)"),(0,r.yg)("li",{parentName:"ul"},"SB2 - if there are at least 2 consecutive bits set (1100-1, 0101-0)")))}m.isMDXComponent=!0}}]); \ No newline at end of file diff --git a/assets/js/runtime~main.20c1d9b0.js b/assets/js/runtime~main.cd914aa8.js similarity index 99% rename from assets/js/runtime~main.20c1d9b0.js rename to assets/js/runtime~main.cd914aa8.js index a2c2f31..a062704 100644 --- a/assets/js/runtime~main.20c1d9b0.js +++ b/assets/js/runtime~main.cd914aa8.js @@ -1 +1 @@ -(()=>{"use strict";var e,f,a,c,b,d={},t={};function r(e){var f=t[e];if(void 0!==f)return f.exports;var a=t[e]={id:e,loaded:!1,exports:{}};return d[e].call(a.exports,a,a.exports,r),a.loaded=!0,a.exports}r.m=d,r.c=t,e=[],r.O=(f,a,c,b)=>{if(!a){var d=1/0;for(i=0;i=b)&&Object.keys(r.O).every((e=>r.O[e](a[o])))?a.splice(o--,1):(t=!1,b0&&e[i-1][2]>b;i--)e[i]=e[i-1];e[i]=[a,c,b]},r.n=e=>{var f=e&&e.__esModule?()=>e.default:()=>e;return r.d(f,{a:f}),f},a=Object.getPrototypeOf?e=>Object.getPrototypeOf(e):e=>e.__proto__,r.t=function(e,c){if(1&c&&(e=this(e)),8&c)return e;if("object"==typeof e&&e){if(4&c&&e.__esModule)return e;if(16&c&&"function"==typeof e.then)return e}var b=Object.create(null);r.r(b);var d={};f=f||[null,a({}),a([]),a(a)];for(var t=2&c&&e;"object"==typeof t&&!~f.indexOf(t);t=a(t))Object.getOwnPropertyNames(t).forEach((f=>d[f]=()=>e[f]));return d.default=()=>e,r.d(b,d),b},r.d=(e,f)=>{for(var a in f)r.o(f,a)&&!r.o(e,a)&&Object.defineProperty(e,a,{enumerable:!0,get:f[a]})},r.f={},r.e=e=>Promise.all(Object.keys(r.f).reduce(((f,a)=>(r.f[a](e,f),f)),[])),r.u=e=>"assets/js/"+({380:"efb5ac27",448:"48f71deb",450:"cfb114e9",505:"b0505eef",556:"cfe36b0d",635:"8aa98e0f",784:"2534586d",943:"1b5abb1d",1022:"2ab605b5",1031:"827f8315",1084:"c14852a1",1307:"1e5b7532",1386:"e3af81fc",1628:"2e544717",1706:"2fccb09f",1727:"0dc4f5e9",2015:"c361f91e",2017:"47c7c7e6",2018:"061587e1",2131:"75a5d4a9",2169:"10d98404",2182:"d4b5fbf4",2278:"23374ca6",2555:"4a108d20",2590:"796dfec5",2655:"83c8eef2",2682:"a6abf77e",2827:"945d5c0d",2840:"3cbdf8f7",2946:"b3ac54c6",3006:"3ba32835",3043:"6eef9636",3121:"b421740f",3130:"9fb710df",3200:"8d96fd57",3241:"e00a167d",3254:"7f3a82c9",3324:"af7f5cd6",3344:"fe5f833c",3533:"d2ae71ae",3555:"c83ed6f9",3603:"46d9fdb3",3654:"98851a70",3683:"dd2fd6f4",3738:"c6a2ccd9",3823:"0812ae0c",3886:"50e1611d",3965:"9fb34271",4003:"e52a1529",4043:"043d1679",4095:"f3cab7e7",4134:"393be207",4224:"7fee8db0",4343:"9d8280b3",4356:"778f886e",4414:"57120277",4419:"7afa6bbe",4737:"cdbfbbf9",4822:"b1bbc9b8",4873:"9ba9fe8f",4999:"6c58b2db",5248:"f4a0e9c9",5707:"cacda006",5954:"73fb5be5",6010:"8ab45a17",6061:"1f391b9e",6358:"cdbb2f31",6749:"6df74a62",6789:"30286595",6969:"14eb3368",7001:"042f603a",7092:"4efc843b",7254:"85b69829",7360:"76a85cfa",7480:"5c9a9d15",7571:"6a0626d1",7629:"e855518e",7924:"9c66197d",8289:"1d48d188",8349:"a1b14c7a",8401:"17896441",8574:"7f754604",8581:"935f2afb",8681:"beb5a70f",8714:"1be78505",8790:"2275ea3b",8959:"78c2f6c7",8980:"65ef72cc",8990:"1f83e87e",9156:"23e6dc00",9226:"60d8238f",9240:"cf377678",9522:"3b5af72c",9779:"9cf1f8cd",9856:"cf22c290"}[e]||e)+"."+{380:"642cb614",448:"3dc77561",450:"ff4124e1",505:"62357c25",556:"18e5f6e0",635:"530ef1b0",784:"e18a95f5",943:"a6f700d3",1022:"d2d8f18e",1031:"1c2b5d42",1084:"d34e04d7",1307:"2319bff6",1386:"bd662dc3",1628:"2e0ce128",1706:"003c33d2",1727:"d37dbd4a",1774:"1ca9710d",2015:"5251dac9",2017:"bb6a90f6",2018:"abf209a6",2131:"ab09d221",2169:"bbb33ec3",2182:"f0af1591",2278:"91bcfb60",2555:"d0063b87",2590:"40eb1072",2655:"3cca0dee",2682:"c6433c17",2827:"5478703a",2840:"9e33d49b",2946:"29cbbda9",3006:"70d4c049",3043:"d6073644",3121:"e930d8db",3130:"780aaef1",3200:"9d454f00",3241:"fe35583a",3254:"dd7ad30b",3324:"646d286b",3344:"e442bb03",3533:"549845cf",3555:"ec7063c1",3603:"46d97a8e",3654:"69a0f723",3683:"6cfe36fd",3738:"489b37df",3823:"d5a8846a",3886:"55ff4536",3965:"c7ccfcd5",4003:"d0b5dc1e",4043:"f83036f1",4095:"752d0ca2",4134:"5c146e5f",4224:"b8be55b4",4343:"967602e3",4356:"26547d4b",4414:"8601519b",4419:"111b1d87",4567:"649b373d",4737:"fd2e8506",4822:"781b12dd",4873:"1e8f18a0",4999:"944cbbc8",5248:"cd3b7335",5707:"9fb47b5a",5954:"f4537401",6010:"18039efb",6061:"f1b26348",6358:"d9e3d153",6749:"b3e39267",6789:"2d91797e",6969:"78deec77",7001:"03a95b5c",7092:"aae46ecc",7254:"de4ada9b",7360:"6f82ae71",7480:"4a15f0b4",7571:"74585fef",7629:"c644832a",7924:"e22faeb8",8289:"9065dc9b",8349:"854395cf",8401:"989705ed",8574:"cbde82ed",8581:"8d6b3e64",8681:"6ee33b31",8714:"0009f9d1",8790:"a0afd402",8959:"2579563e",8980:"efdfc5e5",8990:"0104ef16",9156:"3256ca35",9226:"62e13c3b",9240:"9e4cc6cf",9522:"828f8951",9779:"39b50eba",9856:"fd86e832"}[e]+".js",r.miniCssF=e=>{},r.g=function(){if("object"==typeof globalThis)return globalThis;try{return this||new Function("return this")()}catch(e){if("object"==typeof window)return window}}(),r.o=(e,f)=>Object.prototype.hasOwnProperty.call(e,f),c={},b="computer-architecture:",r.l=(e,f,a,d)=>{if(c[e])c[e].push(f);else{var t,o;if(void 0!==a)for(var n=document.getElementsByTagName("script"),i=0;i{t.onerror=t.onload=null,clearTimeout(s);var b=c[e];if(delete c[e],t.parentNode&&t.parentNode.removeChild(t),b&&b.forEach((e=>e(a))),f)return f(a)},s=setTimeout(l.bind(null,void 0,{type:"timeout",target:t}),12e4);t.onerror=l.bind(null,t.onerror),t.onload=l.bind(null,t.onload),o&&document.head.appendChild(t)}},r.r=e=>{"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})},r.p="/computer-architecture/",r.gca=function(e){return e={17896441:"8401",30286595:"6789",57120277:"4414",efb5ac27:"380","48f71deb":"448",cfb114e9:"450",b0505eef:"505",cfe36b0d:"556","8aa98e0f":"635","2534586d":"784","1b5abb1d":"943","2ab605b5":"1022","827f8315":"1031",c14852a1:"1084","1e5b7532":"1307",e3af81fc:"1386","2e544717":"1628","2fccb09f":"1706","0dc4f5e9":"1727",c361f91e:"2015","47c7c7e6":"2017","061587e1":"2018","75a5d4a9":"2131","10d98404":"2169",d4b5fbf4:"2182","23374ca6":"2278","4a108d20":"2555","796dfec5":"2590","83c8eef2":"2655",a6abf77e:"2682","945d5c0d":"2827","3cbdf8f7":"2840",b3ac54c6:"2946","3ba32835":"3006","6eef9636":"3043",b421740f:"3121","9fb710df":"3130","8d96fd57":"3200",e00a167d:"3241","7f3a82c9":"3254",af7f5cd6:"3324",fe5f833c:"3344",d2ae71ae:"3533",c83ed6f9:"3555","46d9fdb3":"3603","98851a70":"3654",dd2fd6f4:"3683",c6a2ccd9:"3738","0812ae0c":"3823","50e1611d":"3886","9fb34271":"3965",e52a1529:"4003","043d1679":"4043",f3cab7e7:"4095","393be207":"4134","7fee8db0":"4224","9d8280b3":"4343","778f886e":"4356","7afa6bbe":"4419",cdbfbbf9:"4737",b1bbc9b8:"4822","9ba9fe8f":"4873","6c58b2db":"4999",f4a0e9c9:"5248",cacda006:"5707","73fb5be5":"5954","8ab45a17":"6010","1f391b9e":"6061",cdbb2f31:"6358","6df74a62":"6749","14eb3368":"6969","042f603a":"7001","4efc843b":"7092","85b69829":"7254","76a85cfa":"7360","5c9a9d15":"7480","6a0626d1":"7571",e855518e:"7629","9c66197d":"7924","1d48d188":"8289",a1b14c7a:"8349","7f754604":"8574","935f2afb":"8581",beb5a70f:"8681","1be78505":"8714","2275ea3b":"8790","78c2f6c7":"8959","65ef72cc":"8980","1f83e87e":"8990","23e6dc00":"9156","60d8238f":"9226",cf377678:"9240","3b5af72c":"9522","9cf1f8cd":"9779",cf22c290:"9856"}[e]||e,r.p+r.u(e)},(()=>{var e={5354:0,1869:0};r.f.j=(f,a)=>{var c=r.o(e,f)?e[f]:void 0;if(0!==c)if(c)a.push(c[2]);else if(/^(1869|5354)$/.test(f))e[f]=0;else{var b=new Promise(((a,b)=>c=e[f]=[a,b]));a.push(c[2]=b);var d=r.p+r.u(f),t=new Error;r.l(d,(a=>{if(r.o(e,f)&&(0!==(c=e[f])&&(e[f]=void 0),c)){var b=a&&("load"===a.type?"missing":a.type),d=a&&a.target&&a.target.src;t.message="Loading chunk "+f+" failed.\n("+b+": "+d+")",t.name="ChunkLoadError",t.type=b,t.request=d,c[1](t)}}),"chunk-"+f,f)}},r.O.j=f=>0===e[f];var f=(f,a)=>{var c,b,d=a[0],t=a[1],o=a[2],n=0;if(d.some((f=>0!==e[f]))){for(c in t)r.o(t,c)&&(r.m[c]=t[c]);if(o)var i=o(r)}for(f&&f(a);n{"use strict";var e,f,a,c,b,d={},t={};function r(e){var f=t[e];if(void 0!==f)return f.exports;var a=t[e]={id:e,loaded:!1,exports:{}};return d[e].call(a.exports,a,a.exports,r),a.loaded=!0,a.exports}r.m=d,r.c=t,e=[],r.O=(f,a,c,b)=>{if(!a){var d=1/0;for(i=0;i=b)&&Object.keys(r.O).every((e=>r.O[e](a[o])))?a.splice(o--,1):(t=!1,b0&&e[i-1][2]>b;i--)e[i]=e[i-1];e[i]=[a,c,b]},r.n=e=>{var f=e&&e.__esModule?()=>e.default:()=>e;return r.d(f,{a:f}),f},a=Object.getPrototypeOf?e=>Object.getPrototypeOf(e):e=>e.__proto__,r.t=function(e,c){if(1&c&&(e=this(e)),8&c)return e;if("object"==typeof e&&e){if(4&c&&e.__esModule)return e;if(16&c&&"function"==typeof e.then)return e}var b=Object.create(null);r.r(b);var d={};f=f||[null,a({}),a([]),a(a)];for(var t=2&c&&e;"object"==typeof t&&!~f.indexOf(t);t=a(t))Object.getOwnPropertyNames(t).forEach((f=>d[f]=()=>e[f]));return d.default=()=>e,r.d(b,d),b},r.d=(e,f)=>{for(var a in f)r.o(f,a)&&!r.o(e,a)&&Object.defineProperty(e,a,{enumerable:!0,get:f[a]})},r.f={},r.e=e=>Promise.all(Object.keys(r.f).reduce(((f,a)=>(r.f[a](e,f),f)),[])),r.u=e=>"assets/js/"+({380:"efb5ac27",448:"48f71deb",450:"cfb114e9",505:"b0505eef",556:"cfe36b0d",635:"8aa98e0f",784:"2534586d",943:"1b5abb1d",1022:"2ab605b5",1031:"827f8315",1084:"c14852a1",1307:"1e5b7532",1386:"e3af81fc",1628:"2e544717",1706:"2fccb09f",1727:"0dc4f5e9",2015:"c361f91e",2017:"47c7c7e6",2018:"061587e1",2131:"75a5d4a9",2169:"10d98404",2182:"d4b5fbf4",2278:"23374ca6",2555:"4a108d20",2590:"796dfec5",2655:"83c8eef2",2682:"a6abf77e",2827:"945d5c0d",2840:"3cbdf8f7",2946:"b3ac54c6",3006:"3ba32835",3043:"6eef9636",3121:"b421740f",3130:"9fb710df",3200:"8d96fd57",3241:"e00a167d",3254:"7f3a82c9",3324:"af7f5cd6",3344:"fe5f833c",3533:"d2ae71ae",3555:"c83ed6f9",3603:"46d9fdb3",3654:"98851a70",3683:"dd2fd6f4",3738:"c6a2ccd9",3823:"0812ae0c",3886:"50e1611d",3965:"9fb34271",4003:"e52a1529",4043:"043d1679",4095:"f3cab7e7",4134:"393be207",4224:"7fee8db0",4343:"9d8280b3",4356:"778f886e",4414:"57120277",4419:"7afa6bbe",4737:"cdbfbbf9",4822:"b1bbc9b8",4873:"9ba9fe8f",4999:"6c58b2db",5248:"f4a0e9c9",5707:"cacda006",5954:"73fb5be5",6010:"8ab45a17",6061:"1f391b9e",6358:"cdbb2f31",6749:"6df74a62",6789:"30286595",6969:"14eb3368",7001:"042f603a",7092:"4efc843b",7254:"85b69829",7360:"76a85cfa",7480:"5c9a9d15",7571:"6a0626d1",7629:"e855518e",7924:"9c66197d",8289:"1d48d188",8349:"a1b14c7a",8401:"17896441",8574:"7f754604",8581:"935f2afb",8681:"beb5a70f",8714:"1be78505",8790:"2275ea3b",8959:"78c2f6c7",8980:"65ef72cc",8990:"1f83e87e",9156:"23e6dc00",9226:"60d8238f",9240:"cf377678",9522:"3b5af72c",9779:"9cf1f8cd",9856:"cf22c290"}[e]||e)+"."+{380:"642cb614",448:"3dc77561",450:"ff4124e1",505:"62357c25",556:"18e5f6e0",635:"530ef1b0",784:"e18a95f5",943:"a6f700d3",1022:"d2d8f18e",1031:"1c2b5d42",1084:"d34e04d7",1307:"2319bff6",1386:"bd662dc3",1628:"2e0ce128",1706:"003c33d2",1727:"d37dbd4a",1774:"1ca9710d",2015:"5251dac9",2017:"bb6a90f6",2018:"abf209a6",2131:"ab09d221",2169:"bbb33ec3",2182:"f0af1591",2278:"91bcfb60",2555:"d0063b87",2590:"40eb1072",2655:"3cca0dee",2682:"c6433c17",2827:"5478703a",2840:"9e33d49b",2946:"29cbbda9",3006:"70d4c049",3043:"d6073644",3121:"e930d8db",3130:"780aaef1",3200:"9d454f00",3241:"fe35583a",3254:"dd7ad30b",3324:"646d286b",3344:"e442bb03",3533:"5ed938df",3555:"ec7063c1",3603:"46d97a8e",3654:"69a0f723",3683:"6cfe36fd",3738:"489b37df",3823:"d5a8846a",3886:"55ff4536",3965:"c7ccfcd5",4003:"d0b5dc1e",4043:"f83036f1",4095:"752d0ca2",4134:"5c146e5f",4224:"b8be55b4",4343:"967602e3",4356:"26547d4b",4414:"8601519b",4419:"111b1d87",4567:"649b373d",4737:"fd2e8506",4822:"781b12dd",4873:"1e8f18a0",4999:"944cbbc8",5248:"cd3b7335",5707:"9fb47b5a",5954:"f4537401",6010:"18039efb",6061:"f1b26348",6358:"d9e3d153",6749:"b3e39267",6789:"2d91797e",6969:"78deec77",7001:"03a95b5c",7092:"aae46ecc",7254:"de4ada9b",7360:"6f82ae71",7480:"4a15f0b4",7571:"74585fef",7629:"c644832a",7924:"e22faeb8",8289:"9065dc9b",8349:"854395cf",8401:"989705ed",8574:"cbde82ed",8581:"8d6b3e64",8681:"6ee33b31",8714:"0009f9d1",8790:"a0afd402",8959:"2579563e",8980:"efdfc5e5",8990:"0104ef16",9156:"3256ca35",9226:"62e13c3b",9240:"9e4cc6cf",9522:"828f8951",9779:"39b50eba",9856:"fd86e832"}[e]+".js",r.miniCssF=e=>{},r.g=function(){if("object"==typeof globalThis)return globalThis;try{return this||new Function("return this")()}catch(e){if("object"==typeof window)return window}}(),r.o=(e,f)=>Object.prototype.hasOwnProperty.call(e,f),c={},b="computer-architecture:",r.l=(e,f,a,d)=>{if(c[e])c[e].push(f);else{var t,o;if(void 0!==a)for(var n=document.getElementsByTagName("script"),i=0;i{t.onerror=t.onload=null,clearTimeout(s);var b=c[e];if(delete c[e],t.parentNode&&t.parentNode.removeChild(t),b&&b.forEach((e=>e(a))),f)return f(a)},s=setTimeout(l.bind(null,void 0,{type:"timeout",target:t}),12e4);t.onerror=l.bind(null,t.onerror),t.onload=l.bind(null,t.onload),o&&document.head.appendChild(t)}},r.r=e=>{"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})},r.p="/computer-architecture/",r.gca=function(e){return e={17896441:"8401",30286595:"6789",57120277:"4414",efb5ac27:"380","48f71deb":"448",cfb114e9:"450",b0505eef:"505",cfe36b0d:"556","8aa98e0f":"635","2534586d":"784","1b5abb1d":"943","2ab605b5":"1022","827f8315":"1031",c14852a1:"1084","1e5b7532":"1307",e3af81fc:"1386","2e544717":"1628","2fccb09f":"1706","0dc4f5e9":"1727",c361f91e:"2015","47c7c7e6":"2017","061587e1":"2018","75a5d4a9":"2131","10d98404":"2169",d4b5fbf4:"2182","23374ca6":"2278","4a108d20":"2555","796dfec5":"2590","83c8eef2":"2655",a6abf77e:"2682","945d5c0d":"2827","3cbdf8f7":"2840",b3ac54c6:"2946","3ba32835":"3006","6eef9636":"3043",b421740f:"3121","9fb710df":"3130","8d96fd57":"3200",e00a167d:"3241","7f3a82c9":"3254",af7f5cd6:"3324",fe5f833c:"3344",d2ae71ae:"3533",c83ed6f9:"3555","46d9fdb3":"3603","98851a70":"3654",dd2fd6f4:"3683",c6a2ccd9:"3738","0812ae0c":"3823","50e1611d":"3886","9fb34271":"3965",e52a1529:"4003","043d1679":"4043",f3cab7e7:"4095","393be207":"4134","7fee8db0":"4224","9d8280b3":"4343","778f886e":"4356","7afa6bbe":"4419",cdbfbbf9:"4737",b1bbc9b8:"4822","9ba9fe8f":"4873","6c58b2db":"4999",f4a0e9c9:"5248",cacda006:"5707","73fb5be5":"5954","8ab45a17":"6010","1f391b9e":"6061",cdbb2f31:"6358","6df74a62":"6749","14eb3368":"6969","042f603a":"7001","4efc843b":"7092","85b69829":"7254","76a85cfa":"7360","5c9a9d15":"7480","6a0626d1":"7571",e855518e:"7629","9c66197d":"7924","1d48d188":"8289",a1b14c7a:"8349","7f754604":"8574","935f2afb":"8581",beb5a70f:"8681","1be78505":"8714","2275ea3b":"8790","78c2f6c7":"8959","65ef72cc":"8980","1f83e87e":"8990","23e6dc00":"9156","60d8238f":"9226",cf377678:"9240","3b5af72c":"9522","9cf1f8cd":"9779",cf22c290:"9856"}[e]||e,r.p+r.u(e)},(()=>{var e={5354:0,1869:0};r.f.j=(f,a)=>{var c=r.o(e,f)?e[f]:void 0;if(0!==c)if(c)a.push(c[2]);else if(/^(1869|5354)$/.test(f))e[f]=0;else{var b=new Promise(((a,b)=>c=e[f]=[a,b]));a.push(c[2]=b);var d=r.p+r.u(f),t=new Error;r.l(d,(a=>{if(r.o(e,f)&&(0!==(c=e[f])&&(e[f]=void 0),c)){var b=a&&("load"===a.type?"missing":a.type),d=a&&a.target&&a.target.src;t.message="Loading chunk "+f+" failed.\n("+b+": "+d+")",t.name="ChunkLoadError",t.type=b,t.request=d,c[1](t)}}),"chunk-"+f,f)}},r.O.j=f=>0===e[f];var f=(f,a)=>{var c,b,d=a[0],t=a[1],o=a[2],n=0;if(d.some((f=>0!==e[f]))){for(c in t)r.o(t,c)&&(r.m[c]=t[c]);if(o)var i=o(r)}for(f&&f(a);n Notare | Computer Architecture - +

    Notare

    • 50p examen final
    • 50p laborator
      • 10p activitate laborator (prezență si teste surpriză)
      • 10p Test circuite combinaționale
      • 10p Test circuite secvențiale
      • 20p Colocviu final calculator didactic
    • 10p Tema (bonus)

    Promovare:​

    • Minim 25p Laborator
    • Minim 50p Total

    Test circuite combinaționale​

    • Materia necesară: laboratoarele 1,2 și 3
    • Durată: 60 de minute
    • Când: la începutul laboratorului 4
    • Strcutură: 3 exerciții practice de implementat în verilog
    • Locație: sala de laborator
    • Platformă: Calculator Laborator - Moodle - VPL

    Test circuite secvențiale​

    • Materia necesară: laboratoarele 4,5 și 6
    • Durată: 60 de minute
    • Când: la începutul laboratorului 7
    • Strcutură: 3 exerciții practice de implementat în verilog
    • Locație: sala de laborator
    • Platformă: Calculator Laborator - Moodle - VPL

    Colocviu final calculator didactic​

    • Materia necesară: toate laboratoarele
    • Durată: 120 de minute
    • Când: la ultimul laborator
    • Strcutură:
      • 3 exerciții practice de implementat în verilog
      • 20 întrebări teoretice
    • Locație: sala de laborator
    • Platformă: Calculator Laborator - Moodle - VPL/Quiz

    Tema​

    • Durată: Întreg semestrul cu termen limită începutul ultimii săptămâni de laborator
    • Platformă: Moodle - VPL
    • Punctaj: Se va adăuga punctajului de laborator (nu se ia în considerare la punctajul minim)
    • Punctaj: Punctajul total de laborator se trunchiază la 50 de puncte.

    Examen Final (AB)​

    • Platformă: Moodle - VPL/Quiz
    • Durată: 180 de minute
    • Structură:
      • 20 de întrebări teoretice
      • 1 problemă
    Community
    Copyright © 2024 Comnputer Architecture Team
    - + \ No newline at end of file diff --git a/index.html b/index.html index 5a3e2a1..f75a26b 100644 --- a/index.html +++ b/index.html @@ -4,14 +4,14 @@ Descriere | Computer Architecture - +

    Descriere

    Aceasta este pagina pentru cursul de Arhitectectura Calculatoarelor de la Faculatea de Autmatică și Calculatoare parte a Universității Națioanle de Știință și Tehnologie Politehinca București (UNSTPB). Cursul are loc în anul 3 domeniu Ingineria Sistemelor seriile AA, AB și AC.

    În meniu veți putea găsi informații despre regulament, notare, echipă, tutoriale, laboratoare și cursuri.

    Licensing and Contributing​

    The contents are open educational resources (OER), part of the Open Education Hub project; they are hosted on GitHub, licensed under CC BY-SA 4.0 and BSD 3-Clause.

    If you find an issue or want to contribute, follow the contribution guidelines on GitHub.

    Community
    Copyright © 2024 Comnputer Architecture Team
    - + \ No newline at end of file diff --git a/markdown-page/index.html b/markdown-page/index.html index 03e1fb0..e4a386b 100644 --- a/markdown-page/index.html +++ b/markdown-page/index.html @@ -4,13 +4,13 @@ Markdown page example | Computer Architecture - +

    Markdown page example

    You don't need React to write simple standalone pages.

    Community
    Copyright © 2024 Comnputer Architecture Team
    - + \ No newline at end of file diff --git a/rules/index.html b/rules/index.html index 2f40bcd..633dfae 100644 --- a/rules/index.html +++ b/rules/index.html @@ -4,13 +4,13 @@ Regulament | Computer Architecture - +

    Regulament

    Laborator​

    • Textul laboratorului trebuie parcurs înainte de venirea la oră.
    • Schimbarea intervalului asignat în orar este posibilă până la al doilea laborator, dar numai prin schimb cu altă persoană și cu acordul asistenților responsabili de intervalele implicate (nu se pot face schimbări între serii).
    • Recuperarea unui laborator (pierdut sau în avans) este posibilă doar în limita locurilor disponibile la calculatoarele din sală. Înainte de a vă prezenta pentru recuperarea unui laborator trimiteți un e-mail asistentului vostru și asistentului din intervalul în care vreți să recuperați, pentru a obține acordul lor.

    Temă​

    • Copierea temei va duce la sancționarea tuturor celor implicați:
      • Se va face referat studenților implicați
      • Se va anula întreg punctajul obținut în cadrul materii (Va trebui refăcută materia)
    • Folosirea unei rezolvări disponibile online, cu excepția resurselor puse la dispoziție în enunțul temei, este considerată copiere.
    • Trimiterea unei temei care este rezolvată de către o altă persoană decât cel care a încărcat-o este sancționată identic copierii.
    • Puteți fi chemați pentru explicarea în persoană a rezolvării.

    Teste și Colocviu​

    • Copierea sau tentativele de copiere duc la anularea punctajului testului.

    Refacerea laboratorului​

    • Punctajul pentru laborator poate fi obținut printr-una din aceste metode:
      • se păstrează punctajul complet din anii precedenți (dacă respectă condiția de intrare în examen).
      • se reface în totalitate (activitate laborator + teme + teste + colocviu).
    • Refacerea poate fi făcută în orice interval orar, păstrat până la sfârșitul semestrului, în limita locurilor disponibile după anunțarea asistentului prin e-mail.
    Community
    Copyright © 2024 Comnputer Architecture Team
    - + \ No newline at end of file diff --git a/team/index.html b/team/index.html index d4273ee..7a10f12 100644 --- a/team/index.html +++ b/team/index.html @@ -4,13 +4,13 @@ Echipă Architectura Calculatoarelor | Computer Architecture - +

    Echipă Architectura Calculatoarelor

    Profesori​

    SeriaNumeE-mail
    AAacad. prof. dr. ing. Nicolae Țăpușnicolae.tapus@upb.ro
    ABlector dr. ing. Ștefan Dan Ciocîrlanstefan_dan.ciocirlan@upb.ro
    ACconf. dr. ing. Cornel Popescucornel.popescu@upb.ro

    Asistenți​

    Cadre Didactice UNSTPB​

    NumeE-mailGithub
    conf. dr. ing. Cornel Popescucornel.popescu@upb.ro
    lector dr. ing. Ștefan Dan Ciocîrlanstefan_dan.ciocirlan@upb.rosdcioc
    lector dr. ing. Alexandru Predescualexandru.predescu@upb.roalexp25
    lector dr. ing. Eduard Stăniloiueduard.staniloiu@upb.ro
    lector dr. ing. Costin Carabașcostin.carabas@upb.ro
    drd. ing. Daniel Dosarudaniel.dosaru@upb.rodosarudaniel

    Experți Industrie​

    NumeE-mailGithub
    ing. Teodor Dicudicu.teodor@gmail.comDTeodor-Alexaandru
    ing. Cătălin-Ștefan Rucăreanurucareanu2001@gmail.comcatalin-rucareanu2001
    ing. Ionuț Pascalpascal.ionut72@gmail.compascalionut
    ing. Tiberiu Gingutiberiu.gingu22@gmail.comTiberiuGingu

    Tutori​

    NumeE-mailGithub
    Aida Nozohoraidaanozohor@gmail.comaidanozo
    Diana Rusudianarusu199@gmail.comdianarusu1
    Victor Căproiuvictoralice2002@gmail.comVictorCaproiu
    Andrei Batasevga.andrei.batasev@gmail.comPfat8EqualsD
    Samuel Dumitrusamuel.dumitru0220@gmail.comgolem211
    Andrei Cătălincatalinandrei1901@gmail.comcatalin1901

    Alumni​

    Nume
    ing. George Flurche
    ing. Dan Dragomir
    dr. ing. Adrian Drăghici
    lector dr. ing. Giorgiana Vlăsceanu
    ing. George Sârbu
    ing. Sergiu Duda
    ing. Rosana Constantin
    ing. Cristian Constantin
    ing. Ana Cretan
    Community
    Copyright © 2024 Comnputer Architecture Team
    - + \ No newline at end of file