WikiLabs - Contribuții utilizator [ro]

CID aplicatii 4 : Memoria ROM

2026-04-06T13:12:43Z

Cbira: /* Anexa1 */

== Memoria ROM==
Memoria este un dispozitiv electronic utilizat pentru stocarea datelor. Aceasta poate fi de mai multe feluri, având diverse caracteristici, cum ar fi capacitatea de a-și păstra sau nu conținutul după întreruperea alimentării sau capacitatea de a-și modifica sau nu conținutul după terminarea procesului de producție.

Memoria ROM (Read-Only Memory) este un circuit combinațional folosit pentru stocarea unor date ce pot fi accesate cu ajutorul unei intrări de adresă. Asa cum sugerează și numele, memoria ROM clasică nu poate fi modificată. În plus, datorită modului în care este implementată, ea își păstrează conținutul după întreruperea alimentării (este nevolatilă).

Pentru a înțelege termenul de memorie, putem face următorul exercițiu de imaginație: să ne gândim la un dulap cu mai multe sertare. Conținutul memoriei este reprezentat de conținutul sertarelor, iar adresele sunt reprezentate de etichetele lipite pe aceste sertare pentru a le identifica. Dacă avem nevoie de conținutul unui sertar, va trebui să știm eticheta aferentă acestuia (adresa).

O memorie ROM are următorii parametri: numărul de biți ai adresei, care este legat de numarul de locații de memorie (cu n biți de adresă putem forma 2<sup>𝑛</sup> combinații diferite, deci putem accesa maxim 2<sup>𝑛</sup> locații de memorie) și dimensiunea locației de memorie, care ne spune cât de multă informație poate stoca o locație de memorie.

Să urmărim exemplul din figura următoare:

[[Fișier:ROM memory.PNG ‎| 400px]]

Aici, adresa are dimensiunea de 4 biți, asadar putem accesa cu aceasta 16 locații diferite de memorie. Dimensiunea fiecărei locații este de 8 biți, așadar fiecare locație de memorie poate stoca numere de 8 biți. Spunem că memoria ROM este o memorie 16x8. Capacitatea acestei memorii este de 16 x 8 biți = 128 biți.

== Exemple ==

Următoarele circuite pot fi văzute în 2 moduri: ca memorii de tip ROM, cu date de ieșire care depind de adresa (data de intrare) de la care citești cât și ca circuite combinationale a căror ieșire este generată prin porți din intrare.

=== Exemplul 1: Decodorul ===
Decodorul este circuitul care, pentru o anumită valoare a intrării, va genera la ieșire un șir binar care conține 1 pe poziția cu indicele egal cu valorea intrării și 0 in rest. De exemplu, decodorul de mai jos pe 2 biți va avea următoarea corespondență intrare-iesire:

{| class="wikitable"
|- align="center"
||'''in''' || '''out'''
|- align="center"
| 2'b00 || 4'b0001
|- align="center"
|2'b01 || 4'b0010
|- align="center"
|2'b10 || 4'b0100
|- align="center"
|2'b11 || 4'b1000
|}

[[Fișier:Decoder.PNG ‎| 400px]]

Vom implementa acest circuit ca memorie ROM. "in" are rolul de adresa iar out are rolul de date de la adresa respectiva.

'''Implementarea SystemVerilog a circuitului'''
<syntaxhighlight lang="Verilog">
module Decoder(
input logic [1:0] in,
output logic [3:0] out
);

always_comb begin
case(in)
2'b00: out = 4'b0001; //la adresa 0 avem valoarea 1
2'b01: out = 4'b0010; //la adresa 1 avem valoarea 2
2'b10: out = 4'b0100; //la adresa 2 avem valoarea 4
2'b11: out = 4'b1000; //la adresa 3 avem valoarea 8
default: out = 4'b0000;
endcase
end

endmodule
</syntaxhighlight>

'''Implementarea SystemVerilog a modulului de test'''
<syntaxhighlight lang="Verilog">
`timescale 1ns/1ps

module Decoder_TB();
logic [1:0] in_tb;
logic [3:0] out_tb;

integer idx;

initial begin
for(idx=0; idx<4; idx = idx + 1) begin
in_t = idx;
#1;
end
#2 $stop();
end

Decoder DUT(
.in(in_tb),
.out(out_tb)
);

endmodule
</syntaxhighlight>

'''Observații:'''
* Circuitul Decoder va avea o intrare pe 2 biți, care va reprezenta adresa memoriei ROM și o iesire pe 4 biți, reprezentând conținuturile memoriei ROM corespunzătoare fiecărei combinații de la intrare.
* Chiar dacă în interiorul instrucțiunii ''case'' se acoperă toate cazurile posibile (toate combinațiile de 2 biți), este bine sa punem și un ''default'' pentru a evita inserarea în locul circuitului combinațional dorit (aici, memoria ROM) a unui latch.

===Exemplul 2: Transcodorul===
Trancodorul este o memorie ROM care asociază unui anumit cod de intrare, reprezentat de adresă, un anumit cod de ieșire, reprezentat de conținutului locației de memorie asociată acelei adrese.

In acest exemplu, vom folosi transcodorul pentru a realiza un modul ce controlează afișajul cu 7 segmente. Acest dispozitiv de afișare este format, așa cum sugerează și numele, din 7 segmente ce pot fi controlate separat. Putem aprinde sau stinge fiecare segment controlând tensiunea aplicată pe acesta. Pentru acest afișaj, comanda este în logică negativă: aplicând 0 logic pe un segment acesta se va aprinde, iar aplicând 1 logic, acesta se va stinge.

Structura unui afisaj cu 7 segmente este prezentată în imaginea de mai jos:

[[Fișier:7LED display.PNG | 200px]]

Pentru a realiza controlul afișării, avem nevoie de o memorie ROM ce trebuie să asocieze codului binar al fiecărui element ce poate fi afișat un șir de biți care sting sau aprind diversele segmente ale afișajului, astfel încât să apară imaginea elementului dorit.

Pentru a reprezenta, de exemplu, cele 16 numere hexa, segmentele trebuie aprinse conform Anexei 1. De exemplu, pentru primele 8 numere (0 până la 7), tabelul de asociere este următorul:

{| class="wikitable"
|- align="center"
||'''Număr''' || '''Cod intrare''' || '''Șir de afisare'''
|- align="center"
| 0 || 4'b0000 || 7'b100_0000
|- align="center"
| 1 || 4'b0001 || 7'b111_1001
|- align="center"
| 2 || 4'b0010 || 7'b010_0100
|- align="center"
| 3 || 4'b0011 || 7'b011_0000
|- align="center"
| 4 || 4'b0100 || 7'b001_1001
|- align="center"
| 5 || 4'b0101 || 7'b001_0010
|- align="center"
| 6 || 4'b0110 || 7'b000_0010
|- align="center"
| 7 || 4'b0111 || 7'b111_1000
|}

'''Implementarea SystemVerilog a modulului Display7Seg'''
<syntaxhighlight lang="Verilog">
module Display7Seg(
input logic [3:0] in,
output logic [6:0] out
);

always_comb begin
case(in)
4'd0: out = 7'b1000000;
4'd1: out = 7'b1111001;
4'd2: out = 7'b0100100;
4'd3: out = 7'b0110000;
4'd4: out = 7'b0011001;
4'd5: out = 7'b0010010;
4'd6: out = 7'b0000010;
4'd7: out = 7'b1111000;
default: out = 7'b0000110;
endcase
end

endmodule
</syntaxhighlight>

== Exerciții:==
=== Exercițiul 1===
Completați codul din Exemplul 2 astfel încât să se poată reprezenta toate numerele în bază 16 (hexazecimal), conform Anexei 1

=== Exercițiul 2===
Un procesor are nevoie de un șir de biți numit instrucțiune pentru a știi ce trebuie să facă. Această instrucțiune codează în șirul său de biți toate informațiile necesare.

De exemplu, pentru un grup de instrucțiuni care operează cu registre, aceste informații pot fi:
* codul instrucțiunii (operation code - opcode): un șir de biți care ne spune ce operație se execută.
* destinația: un șir de biți care codează numărul registrului destinație.
* sursa1: un șir de biți care codează numărul registrului folosit ca operand 1.
* sursa2: un șir de biți care codează numărul registrului folosit ca operand 2.

Vom considera codul operației pe 4 biți, ceea ce inseamnă ca putem avea 16 instrucțiuni diferite. In plus, câmpurile care codează destinația și cei doi operanzi vor avea fiecare câte 4 biți, ceea ce inseamnă că vom avea 16 registre cu care putem lucra (R0 ... R15). Adunând dimensiunile fiecărui câmp, vom obține o instrucțiune pe 16 biți.

'''Instrucțiunile și codul operațiilor:'''

Vom considera ca procesorul nostru elementar poate suporta următoarele instrucțiuni:

{| class="wikitable"
|- align="center"
||'''Operație''' || '''Cod operație''' || '''Sintaxă''' ||'''Descriere'''
|- align="center"
| ADD || 4'b0000 || ADD Rd Rs1 Rs2 || Rd = Rs1 + Rs2
|- align="center"
| SUB || 4'b0001 || SUB Rd Rs1 Rs2 || Rd = Rs1 - Rs2
|- align="center"
| OR || 4'b0010 || OR Rd Rs1 Rs2 || Rd = Rs1 OR Rs2
|- align="center"
| AND || 4'b0011 || AND Rd Rs1 Rs2 || Rd = Rs1 AND Rs2
|- align="center"
| LOADC || 4'b0100 || LOADC Rd, const || Rd = const
|}

Pentru instrucțiunile prezentate mai sus, vom avea următoarele moduri de codare (de împărțire a informației în cadrul instrucțiunii):

[[Fișier:Codare instructiune.png | 400px]]

'''Registrele:'''

Cele 16 registre vor fi codate cu un număr egal cu indexul său. De exemplu, R0 va avea codul 4'b000, R1 va avea codul 4'b0001 și așa mai departe.

Considerând cele spuse mai sus, vom avea următoarele exemple de instrucțiuni:

[[Fișier:Exemple codare instructiuni.png | 400px]]

Având toate informațiile de mai sus, descrieți o memorie ROM cu adresă pe 4 biți și locații pe 16 biți, care să conțină următorul program, începând cu adresa 0:

<syntaxhighlight lang="Verilog">

LOADC R0, 2h
LOADC R1, 5h
LOADC R2, 7h
ADD R3, R1, R0
SUB R4, R2, R1
OR R5, R3, R4

</syntaxhighlight>

=== Exercițiul 3===
Proiectați un Codor Cezar cu cheie fixă sub forma unei memorii ROM.

Un Codor Cezar preia un mesaj și codează independent fiecare literă a acestuia pentru a obține un mesaj cifrat. El se folosește de o cheie fixă care se adună la fiecare literă a mesajului. De exemplu, pentru cheia "+3": a->d; b->e; c->f;...; y->b; z->c. Observați că atunci când alfabetul a ajuns la capăt, se reia de la început.
Pentru decodare, se va folosi procedura inversă: pentru fiecare literă, vom aplica cheia cu semn invers (în exemplul nostru, cheia de decodare este "-3").

Observații, sfaturi, task-uri suplimentare:
* Codorul va putea prelucra doar litere mici și spațiu gol (acesta rămâne neschimbat).
* Cel mai usor mod de a scrie această funcționalitate este folosind un bloc de tip ''case''.
* Pentru testare, se pot folosi în testbench variabile de tip ''logic'' pe 8 biți, astfel:
<syntaxhighlight lang="Verilog">
logic [7:0] litera;
litera = "A";
</syntaxhighlight>
* Avansat: În SystemVerilog există și tipul de date ''string'', ceea ce permite parcurgerea cu un ''for'' a mesajului. În Verilog clasic, astfel de parcurgeri sunt posibile, dar sintaxa este mai complicată.
* Se va folosi codul ASCII pentru valori. Pentru o ușoara vizualizare a datelor în simulare, se poate schimba radix-ul în ASCII.
* Avansat: Pentru a testa automat codul, se poate instanția încă un modul în testbench cu aceeași funcționalitate pe post de "golden model". Acest modul nu trebuie să fie sintetizabil și atunci sintaxa permite mai multă libertate (cum ar fi operația de modulo "%", utilă pentru testare, dar care determină un circuit complicat dacă ar fi sintetizată). Ieșirile celor două module din testbench sunt apoi comparate pentru a se verifica că ambele implementări oferă același rezultat.
* Implementați și Decodorul Cezar și testați Codorul împreună cu acesta. Aveți grijă ca cele două module să aibă aceeași cheie.

==Anexa1==

[[Fișier:Anexa1modificat9.png | 800px]]

CID aplicatii 4 : Memoria ROM

2026-04-06T13:12:13Z

Cbira: /* Anexa1 */

Fișier:Anexa1modificat9.png

2026-04-06T13:11:56Z

Cbira:

Fișier:Anexa1.png

2026-04-06T13:03:33Z

Cbira:

CID aplicatii 5 : Exercitii cu circuite combinationale

2026-03-23T13:02:34Z

Cbira: /* Teorie: Parametrizare */

==Teorie==

Acest laborator are rolul de a sedimenta cunostiintele dobandite anterior.

El consta in exercitii separate, unele date ca subiect la lucrarea 1 in anii anteriori si cateva notiuni de teorie si sintaxa ajutatoare.

==Teorie: Parametrizare==
Parametrizarea este un mod de a generaliza codul scris pentru a nu fi necesara descrierea aceluiasi modul de mai multe ori (daca circuitul isi schimba o dimensiune).

Pentru a intelege mai clar avantajele si sintaxa urmariti urmatorul exemplu:

Fisierul sumator.sv:
<syntaxhighlight lang="Verilog">
module sumator # // <= diez deoarece urmeaza lista cu parametri
( // parametri
parameter data_size = 4 // valoare default 4
// alti parametri aici daca este nevoie, separati prin virgula
)
( // interfata
input logic [data_size-1:0] in0, // si pot folosi parametrul "data_size" pentru dimensiunea bus-ului
input logic [data_size-1:0] in1,
output logic [data_size-1:0] out0
);

assign out0 = in0 + in1;

endmodule
</syntaxhighlight>

Cand se instantiaza un modul parametrizat, se specifica valorile parametrilor astfel:
<syntaxhighlight lang="Verilog">
sumator # ( // parametri
.data_size(8) // se genereaza un sumator pe 8b
)
nume_instanta_0
( // interfata
.in0(fir_in0),
.in1(fir_in1),
.out0(fir_out0)
);

sumator # ( // parametri
.data_size(32) // se genereaza un sumator pe 32b
)
nume_instanta_1
( // interfata
.in0(fir_in0),
.in1(fir_in1),
.out0(fir_out1)
);

sumator nume_instanta_2 // se genereaza un sumator de dimensiune default, aici 4, asa cum e scris in modulul "sumator"
( // interfata
.in0(fir_in0),
.in1(fir_in1),
.out0(fir_out2)
);
</syntaxhighlight>

Puteti folosi parametrizarea in exercitiul 3 de mai jos. Acolo sunt 2 tipuri de multiplexoare, unul cu intrarile pe 1 bit si unul cu intrarile pe 2 biti. Poate fi scris un singur modul parametrizat care sa acopere ambele situatii.

==Teorie: Concatenarea==

Pentru o mai usoara conectare a firelor sau pentru o mai buna organizare si expresivitate a codului, de multe ori este util ca fire individuale sa fie grupate impreuna sau ca un bus de mai multi biti sa fie separat in fire individuale. Acest lucru se face folosind concatenarea, prin simbolurile "{ }".

Un exemplu de folosire a concatenarii este oferit mai jos.
Un sumator pe 8b are rezultatul pe maxim 9b, in cazul in care ambele numere sunt mari. Astfel apare un bit de carry out.
<syntaxhighlight lang="Verilog">
module sumator (
input logic [7:0] in0,
input logic [7:0] in1,
output logic [7:0] out0,
output logic carry_out
);

assign {carry_out,out0} = in0 + in1; // fac suma intre in0 si in1 iar rezultatul il pun pe cei 9b alcatuiti din: 1b carry_out si 8b out0, in ordinea asta

endmodule
</syntaxhighlight>
Se pot concatena oricat de multe semnale, puse in "{ }" si separate prin virgula. Atentie la dimensiunile firelor care se concateneaza.

Se poate de asemenea face concatenare si la dreapta egalului, astfel:
<syntaxhighlight lang="Verilog">
assign fir_pe_10_b = {fir_pe_3b,fir_pe_5b,fir_pe_1b,fir_pe_1b};
</syntaxhighlight>
In exemplul anterior ultimi 2b ai "fir_pe_10_b" vor avea mereu aceeasi valoare, provenind din acelasi fir. Sintaxa SystemVerilog permite asta.

Puteti folosii concatenarea, in exercitiul 2, la flag-ul de overflow.

==Teorie: Constante ca intrari in circuite==
In cazul in care se doreste scrierea unor constante la intrarea unor module, acestea se pun direct intre paranteze la instantiere.
De exemplu, pentru multiplexorul de jos din subiectul "alu structural", intrarea "in3" este conectata la valoarea "1". Sintaxa pentru aceasta este: ".in3(1),".

==Teorie: "_"==
Simbolul "_" (underscore) este ignorat de SystemVerilog si ajuta vizual la citirea semnalelor pe mai multi biti. De exemplu 16'b1010010111110000 este identic cu 16'b1010_0101_1111_0000, al doilea fiind totusi mai usor de citit.

==Exercitii==

===Exercitiul 0: Repararea erorilor===
Arhiva de mai jos contine mai multe proiecte in Vivado, fiecare avand cate o eroare de sintaxa sau de logica. In vederea aprofundari cunostiintelor voastre (si pentru lucrarea de saptamana urmatoare), incercati sa le parcurgeti si sa rezolvati toate problemele.
Pe langa proiecte in sine, in arhiva se afla si un fisier text cu o introducere, rezolvarile si explicatiile pentru fiecare situatie.

[https://drive.google.com/file/d/1cNTpQC54_JEeSk8SxgHTEdGtobCn_-EI/view?usp=drive_link Arhiva_proiecte_cu_erori.zip]

===Exercitiul 1: ALU - descriere comportamentala===
Descrieți comportamental o unitate aritmetico-logică (ALU) care are la intrare 2 numere binare de câte 8 biți și poate calcula următoarele funcții:
:- suma celor două numere
:- diferența celor două numere
:- operații logice bit cu bit (bitwise): SI, SAU, XOR și inversele lor
:- operandul din stanga trece neschimbat
:- operandul din dreapta trece neschimbat
:- numărul din stânga este deplasat la stânga cu nr. de poziții indicat de numărul din dreapta
:- numărul din stânga este deplasat la dreapta cu nr. de poziții indicat de numărul din dreapta

Funcția executată la un anumit moment este determinată de configurația binară de pe intrarea de comandă (function).

ALU are de asemenea intrare de carry și ieșire de carry, plus alte două ieșiri - indicatori - pentru cazurile când rezultatul este zero și când cei doi operanzi sunt egali.

Intrarea de control va fi facuta pe 4 biti ca sa permita existenta a 16 operatii posibile. Fiecare numar de pe intrarea de control (combinatie de 0 si 1) va reprezenta o operatie din cele de mai sus. Scrierea se va face folosind un bloc "case" in functie de aceasta intrare.

===Exercitiul 2: ALU - descriere structurala===

[https://wiki.dcae.pub.ro/images/8/8f/Subiect_big_alu.pdf subiect_alu.pdf]

Daca se doreste selectarea doar a anumitor biti dintr-un bus (cum se vrea din instruction) acest lucru se poate face in 2 feluri:

a) cu fir aditional:
:''wire [1:0] fir_aditional1;''
:''assign fir_aditional1 = instruction[11:10];''
:// apoi la instantiere: ''.sel(fir_aditional1),''

b) direct in instantiere;
:la instantierea celor 2 mux4 din stanga, direct:
::''.sel(instruction[11:10]),''

Pentru a scrie mai putin (a nu face toate modulele de calcul separat + instantierea lor) si pentru ca e vorba de operatii simple, se poate pune operatia cu assign direct in top pe un fir declarat acolo, sau si mai prescurtat, direct operatia dorita cand se intantiaza modulul in care aceasta intra. De exemplu, pentru operatia de shift la dreapta care intra in primul multiplexor, se poate pune: ".in0(data0 >> data1),".

===Exercitiul 3: Multiplexoare===

[https://wiki.dcae.pub.ro/images/3/3a/Subiect_muxes.pdf subiect_muxes.pdf]

===Exercitiul 4: Rom/Look-up table===

[https://wiki.dcae.pub.ro/images/2/2e/Subiect_rom_luts.pdf rom_luts.pdf]

===Exercitiul 5: Sumator cu reprezentare in cifre zecimale===
Proiectati si verificati un sumator zecimal pentru numere cu 2 cifre

Modulul de top (Figura 1) este alcatuit din 2 blocuri de tip '''digitsum'''. Fiecare bloc aduna cifrele de pe aceasi pozitie.

'''Figura 1'''
Top level

[[Fișier: bcdsum.png]]

Blocul '''digitsum''' (Figura 2) este alcatuit din 4 blocuri, 2 sumatoare binare pe 4 biti (de tip '''sum4'''), o instanta de '''cmp''' si un multiplexor elementar mux2

'''Figura 2'''
Blocul DIGIT SUM

[[Fișier: digit.png]]

Primul sumator aduna cifrele din domeniul [0...9] avand un rezultat intre [0 ... 18]

Comparatorul are la iesire 1 daca rezultatul este mai mare decat 9.

Daca rezultatul este mai mic decat 9, acesta este trimis in mod direct la iesirea '''digit''' a blocului '''digitsum'''.

Daca rezultatul este mai mare decat 9, o crectie este necesara si se aduna 6 la rezultat.

Comparatorul cu valoarea 9 este descris structural din porti in figura de mai jos:

'''Figure 3'''
the comparator

[[Fișier: cmp.png]]

Testbench-ul va genera stimuli pentru '''bcdsum''' ca in Figura 4.

Intrarea b0 a '''bcdsum''' se schimba la fiecare 5 pasi de simulare .

b1, a0 si a1 se schimba sincron cu b0 ca in Figura 4.

'''Figure 4'''

[[Fișier: teststimuli.png]]

Cerinte:
# '''cmp'''- descris structural la nivel de porti ca in Figura 3.
# '''sum4''' descris comportamental cu un assign continuu.
# '''mux''' descris comportamental cu always.
# '''digitsum''' descris strctural ca in Figura 2.
# modulul de top numit '''bcdsum''', descris structural ca in Figure 1.
# modulul de testbench, '''bcdsum_tb''', instantiaza '''bcdsum''' cu numele '''dut'''.
# in testbench, generati stimuli pentru intrarile circuitului testat.

===Exercitiul 6: Codor Cezar===

[https://wiki.dcae.pub.ro/images/9/92/Cid_L1_codor_Cezar.pdf Codor_Cezar.pdf]

===Exercitiul 7: Calcul si Flag-uri===

[https://wiki.dcae.pub.ro/images/c/c2/L1_calcul_si_flaguri.pdf Calcul_si_flaguri.pdf]

===Exercitiul 8: Unitate aritmetico-logică (ALU)===

[https://wiki.dcae.pub.ro/images/8/85/Subiect_ALU_pentru_wiki.pdf Unitate_aritmetico-logica]

CID aplicatii 5 : Exercitii cu circuite combinationale

2026-03-23T13:01:55Z

Cbira: /* Teorie: Parametrizare */

==Teorie==

Acest laborator are rolul de a sedimenta cunostiintele dobandite anterior.

El consta in exercitii separate, unele date ca subiect la lucrarea 1 in anii anteriori si cateva notiuni de teorie si sintaxa ajutatoare.

==Teorie: Parametrizare==
Parametrizarea este un mod de a generaliza codul scris pentru a nu fi necesara descrierea aceluiasi modul de mai multe ori (daca circuitul isi schimba o dimensiune).

Pentru a intelege mai clar avantajele si sintaxa urmariti urmatorul exemplu:

Fisierul sumator.sv:
<syntaxhighlight lang="Verilog">
module sumator # // <= diez deoarece urmeaza lista cu paramteri
( // parametri
parameter data_size = 4 // valoare default 4
// alti parametri aici daca este nevoie, separati prin virgula
)
( // interfata
input logic [data_size-1:0] in0, // si pot folosii parametrul "data_size" pentru dimensiunea bus-ului
input logic [data_size-1:0] in1,
output logic [data_size-1:0] out0
);

assign out0 = in0 + in1;

endmodule
</syntaxhighlight>

Cand se instantiaza un modul parametrizat, se specifica valorile parametrilor astfel:
<syntaxhighlight lang="Verilog">
sumator # ( // parametri
.data_size(8) // se genereaza un sumator pe 8b
)
nume_instanta_0
( // interfata
.in0(fir_in0),
.in1(fir_in1),
.out0(fir_out0)
);

sumator # ( // parametri
.data_size(32) // se genereaza un sumator pe 32b
)
nume_instanta_1
( // interfata
.in0(fir_in0),
.in1(fir_in1),
.out0(fir_out1)
);

sumator nume_instanta_2 // se genereaza un sumator de dimensiune default, aici 4, asa cum e scris in modulul "sumator"
( // interfata
.in0(fir_in0),
.in1(fir_in1),
.out0(fir_out2)
);
</syntaxhighlight>

Puteti folosi parametrizarea in exercitiul 3 de mai jos. Acolo sunt 2 tipuri de multiplexoare, unul cu intrarile pe 1 bit si unul cu intrarile pe 2 biti. Poate fi scris un singur modul parametrizat care sa acopere ambele situatii.

==Teorie: Concatenarea==

Pentru o mai usoara conectare a firelor sau pentru o mai buna organizare si expresivitate a codului, de multe ori este util ca fire individuale sa fie grupate impreuna sau ca un bus de mai multi biti sa fie separat in fire individuale. Acest lucru se face folosind concatenarea, prin simbolurile "{ }".

Un exemplu de folosire a concatenarii este oferit mai jos.
Un sumator pe 8b are rezultatul pe maxim 9b, in cazul in care ambele numere sunt mari. Astfel apare un bit de carry out.
<syntaxhighlight lang="Verilog">
module sumator (
input logic [7:0] in0,
input logic [7:0] in1,
output logic [7:0] out0,
output logic carry_out
);

assign {carry_out,out0} = in0 + in1; // fac suma intre in0 si in1 iar rezultatul il pun pe cei 9b alcatuiti din: 1b carry_out si 8b out0, in ordinea asta

endmodule
</syntaxhighlight>
Se pot concatena oricat de multe semnale, puse in "{ }" si separate prin virgula. Atentie la dimensiunile firelor care se concateneaza.

Se poate de asemenea face concatenare si la dreapta egalului, astfel:
<syntaxhighlight lang="Verilog">
assign fir_pe_10_b = {fir_pe_3b,fir_pe_5b,fir_pe_1b,fir_pe_1b};
</syntaxhighlight>
In exemplul anterior ultimi 2b ai "fir_pe_10_b" vor avea mereu aceeasi valoare, provenind din acelasi fir. Sintaxa SystemVerilog permite asta.

Puteti folosii concatenarea, in exercitiul 2, la flag-ul de overflow.

==Teorie: Constante ca intrari in circuite==
In cazul in care se doreste scrierea unor constante la intrarea unor module, acestea se pun direct intre paranteze la instantiere.
De exemplu, pentru multiplexorul de jos din subiectul "alu structural", intrarea "in3" este conectata la valoarea "1". Sintaxa pentru aceasta este: ".in3(1),".

==Teorie: "_"==
Simbolul "_" (underscore) este ignorat de SystemVerilog si ajuta vizual la citirea semnalelor pe mai multi biti. De exemplu 16'b1010010111110000 este identic cu 16'b1010_0101_1111_0000, al doilea fiind totusi mai usor de citit.

==Exercitii==

===Exercitiul 0: Repararea erorilor===
Arhiva de mai jos contine mai multe proiecte in Vivado, fiecare avand cate o eroare de sintaxa sau de logica. In vederea aprofundari cunostiintelor voastre (si pentru lucrarea de saptamana urmatoare), incercati sa le parcurgeti si sa rezolvati toate problemele.
Pe langa proiecte in sine, in arhiva se afla si un fisier text cu o introducere, rezolvarile si explicatiile pentru fiecare situatie.

[https://drive.google.com/file/d/1cNTpQC54_JEeSk8SxgHTEdGtobCn_-EI/view?usp=drive_link Arhiva_proiecte_cu_erori.zip]

===Exercitiul 1: ALU - descriere comportamentala===
Descrieți comportamental o unitate aritmetico-logică (ALU) care are la intrare 2 numere binare de câte 8 biți și poate calcula următoarele funcții:
:- suma celor două numere
:- diferența celor două numere
:- operații logice bit cu bit (bitwise): SI, SAU, XOR și inversele lor
:- operandul din stanga trece neschimbat
:- operandul din dreapta trece neschimbat
:- numărul din stânga este deplasat la stânga cu nr. de poziții indicat de numărul din dreapta
:- numărul din stânga este deplasat la dreapta cu nr. de poziții indicat de numărul din dreapta

Funcția executată la un anumit moment este determinată de configurația binară de pe intrarea de comandă (function).

ALU are de asemenea intrare de carry și ieșire de carry, plus alte două ieșiri - indicatori - pentru cazurile când rezultatul este zero și când cei doi operanzi sunt egali.

Intrarea de control va fi facuta pe 4 biti ca sa permita existenta a 16 operatii posibile. Fiecare numar de pe intrarea de control (combinatie de 0 si 1) va reprezenta o operatie din cele de mai sus. Scrierea se va face folosind un bloc "case" in functie de aceasta intrare.

===Exercitiul 2: ALU - descriere structurala===

[https://wiki.dcae.pub.ro/images/8/8f/Subiect_big_alu.pdf subiect_alu.pdf]

Daca se doreste selectarea doar a anumitor biti dintr-un bus (cum se vrea din instruction) acest lucru se poate face in 2 feluri:

a) cu fir aditional:
:''wire [1:0] fir_aditional1;''
:''assign fir_aditional1 = instruction[11:10];''
:// apoi la instantiere: ''.sel(fir_aditional1),''

b) direct in instantiere;
:la instantierea celor 2 mux4 din stanga, direct:
::''.sel(instruction[11:10]),''

Pentru a scrie mai putin (a nu face toate modulele de calcul separat + instantierea lor) si pentru ca e vorba de operatii simple, se poate pune operatia cu assign direct in top pe un fir declarat acolo, sau si mai prescurtat, direct operatia dorita cand se intantiaza modulul in care aceasta intra. De exemplu, pentru operatia de shift la dreapta care intra in primul multiplexor, se poate pune: ".in0(data0 >> data1),".

===Exercitiul 3: Multiplexoare===

[https://wiki.dcae.pub.ro/images/3/3a/Subiect_muxes.pdf subiect_muxes.pdf]

===Exercitiul 4: Rom/Look-up table===

[https://wiki.dcae.pub.ro/images/2/2e/Subiect_rom_luts.pdf rom_luts.pdf]

===Exercitiul 5: Sumator cu reprezentare in cifre zecimale===
Proiectati si verificati un sumator zecimal pentru numere cu 2 cifre

Modulul de top (Figura 1) este alcatuit din 2 blocuri de tip '''digitsum'''. Fiecare bloc aduna cifrele de pe aceasi pozitie.

'''Figura 1'''
Top level

[[Fișier: bcdsum.png]]

Blocul '''digitsum''' (Figura 2) este alcatuit din 4 blocuri, 2 sumatoare binare pe 4 biti (de tip '''sum4'''), o instanta de '''cmp''' si un multiplexor elementar mux2

'''Figura 2'''
Blocul DIGIT SUM

[[Fișier: digit.png]]

Primul sumator aduna cifrele din domeniul [0...9] avand un rezultat intre [0 ... 18]

Comparatorul are la iesire 1 daca rezultatul este mai mare decat 9.

Daca rezultatul este mai mic decat 9, acesta este trimis in mod direct la iesirea '''digit''' a blocului '''digitsum'''.

Daca rezultatul este mai mare decat 9, o crectie este necesara si se aduna 6 la rezultat.

Comparatorul cu valoarea 9 este descris structural din porti in figura de mai jos:

'''Figure 3'''
the comparator

[[Fișier: cmp.png]]

Testbench-ul va genera stimuli pentru '''bcdsum''' ca in Figura 4.

Intrarea b0 a '''bcdsum''' se schimba la fiecare 5 pasi de simulare .

b1, a0 si a1 se schimba sincron cu b0 ca in Figura 4.

'''Figure 4'''

[[Fișier: teststimuli.png]]

Cerinte:
# '''cmp'''- descris structural la nivel de porti ca in Figura 3.
# '''sum4''' descris comportamental cu un assign continuu.
# '''mux''' descris comportamental cu always.
# '''digitsum''' descris strctural ca in Figura 2.
# modulul de top numit '''bcdsum''', descris structural ca in Figure 1.
# modulul de testbench, '''bcdsum_tb''', instantiaza '''bcdsum''' cu numele '''dut'''.
# in testbench, generati stimuli pentru intrarile circuitului testat.

===Exercitiul 6: Codor Cezar===

[https://wiki.dcae.pub.ro/images/9/92/Cid_L1_codor_Cezar.pdf Codor_Cezar.pdf]

===Exercitiul 7: Calcul si Flag-uri===

[https://wiki.dcae.pub.ro/images/c/c2/L1_calcul_si_flaguri.pdf Calcul_si_flaguri.pdf]

===Exercitiul 8: Unitate aritmetico-logică (ALU)===

[https://wiki.dcae.pub.ro/images/8/85/Subiect_ALU_pentru_wiki.pdf Unitate_aritmetico-logica]

Performance analysis and optimization

2026-03-09T08:38:02Z

Cbira: /* Lab sessions */

= Results =

https://docs.google.com/spreadsheets/d/1GvZ-P-MEA9iPuBFx2onQ8qg0o2cDQSoWFV2Y0T11Fls/edit?usp=sharing

= Support materials =

http://www.agner.org/optimize/optimizing_cpp.pdf

https://www.arm.com/files/pdf/AT_-_Better_C_Code_for_ARM_Devices.pdf

= Lab sessions =

Contact: calin.bira_AT_upb.ro

2026-02-20T07:46:06Z

2026-02-20T07:34:16Z

Cbira: Pagină nouă: În acest laborator ne vom reaminti sintaxa limbajului C, vom exersa utilizarea mediului de dezvoltare CLion și a ''debugger''-ului. == Tool-ul de depanare GDB == Depanatorul GNU...

În acest laborator ne vom reaminti sintaxa limbajului C, vom exersa utilizarea mediului de dezvoltare CLion și a ''debugger''-ului.

== Tool-ul de depanare GDB ==
Depanatorul GNU, cunoscut drept GDB (GNU debugger), este depanatorul standard pentru sistemul de software GNU.<br>
Scopul unui depanator precum GDB este de a permite utilizatorului să vadă ce se întâmplă în interiorul unui alt program în timp ce acesta se execută (pentru a determina motivul rezultatelor necorespunzătoare) sau ce s-a întâmplat cu programul în momentul în care a fost întreruptă execuţia în mod neaşteptat.<br><br>

GDB este capabil de a îndeplini 4 categorii de operații (și alte operaţii intermediare lor):
* să pornească programul, specificând orice ar putea interveni în buna funcționare a acestuia;
* să determine o pauză in execuţia programului în anumite condiții specificate de utilizator;
* să examineze ce s-a întâmplat în momentul opririi programului;
* să modifice anumite valori în program pentru a putea corecta efectele unui bug și a investiga urmările altuia.<br>
Odată pornit, GDB citește comenzi din terminal până la întâlnirea comenzii de ieșire "quit".<br>
<div class="regula">'''<font color="red"> Atenție:</font>''' Pentru a putea folosi debugger-ul, la generarea fișierului executabil trebuie folosită opțiunea '''-g''', care adaugă simboluri de debug în executabil, fără de care depanarea nu este posibilă. (vezi [http://wiki.dcae.pub.ro/index.php/PC_Laborator_1 Laboratorul 1])</div>
Exemplul unei comenzi de compilare în vederea depanării:<br>

'''<span style="color: green">student@pracsis01</span> <span style="color: blue">~/Desktop $</span> gcc -g hello.c -o hello'''

=== Comenzi specifice GDB ===
Cea mai folosită modalitate de a porni tool-ul de depanare este de a scrie '''gdb''' în terminal, urmat de numele executabilului ce se dorește a fi depanat.

'''<span style="color: green">student@pracsis01</span> <span style="color: blue">~/Desktop $</span> gdb hello'''

O parte din comenzile cele mai utilizate ale GDB sunt următoarele (pentru lista completă studiați pagina de manual GDB - man gdb):
{| class="wikitable"
! Opțiune !! Efect
|-
| <code style="color: green">break</code> [nume_fișier:] nume_funcție <br> <code style="color: green">break</code> [nume_fișier:] număr_linie || Setează un breakpoint (punct de întrerupere) la începutul funcției ''nume_funcție'' sau la linia specificată prin ''număr_linie'' din fișierul specificat prin ''nume_fișier''.
|-
| <code style="color: green">run</code> [listă_argumente] || Pornește programul în execuție (cu lista de argumente, dacă au fost specificate).
|-
| <code style="color: green">bt</code> || Backtrace: afișează stiva de program.
|-
| <code style="color: green">print</code> expresie || Afișează valoarea unei expresii (valoarea stocată într-o variabilă, valoarea returnată de o funcție etc.).
|-
| <code style="color: green">c</code> || Continuă execuția programului (după ce a fost oprit, spre exemplu după un breakpoint).
|-
| <code style="color: green">next</code> || Execută următoarea linie de program (după oprire), sărind peste orice apel de funcție care se găsește în această linie.
|-
| <code style="color: green">list</code> [nume_fișier:] nume_funcție || Afișează liniile de cod ale programului din vecinătatea locului unde este oprit acum.
|-
| <code style="color: green">step</code> || Execută următoarea linie de program (după oprire), intrând în orice funcție apelată de acea linie.
|-
| <code style="color: green">help</code> [nume] || Afișează informații despre comanda GDB ''nume'' sau informații generale despre utilizarea GDB.
|-
| <code style="color: green">quit</code> || Iese din GDB.
|}

<div class="regula"> ''' Observație: ''' Cele mai multe dintre aceste comenzi pot fi apelate doar prin prima literă a numelui lor. </div>
Spre exemplu, următoarea comandă:
'''(gdb) next'''
este identică cu:
'''(gdb) n'''
<div class="regula"> ''' Observație: ''' Dacă se apasă pe enter fără a scrie o comandă, se repetă ultima comandă specificată.</div>

=== Exemplu de depanare ===
Se dă fișierul sursă ''suma_fact.c'', care conține următoarele instrucțiuni:
<syntaxhighlight lang="C">
#include<stdio.h>

unsigned int factorial(int n) {
if (n == 0) {
return 1;
}
int i;
unsigned int fact = 0;
for (i = 1; i <= n; i++){
fact *= i;
}
return fact;
}

int main() {
int n, i;
do {
printf("Introduceti un numar natural mai mic sau egal cu 8: ");
scanf("%d", &n);
} while (n < 0 || n > 8);
unsigned int suma = 0;
for (i = 0; i <= n; i++) {
suma += factorial(i);
}
printf("%u\n", suma);
return 0;
}
</syntaxhighlight>
Programul își propune să calculeze suma factorialelor de la 0 la n, unde n este introdus de la tastatură. Dacă rulăm programul vom obține ca rezultat numărul '''1''', indiferent de ce a fost introdus de la tastatură. Ne propunem să descoperim bug-ul folosind GDB.<br>
Compilăm sursa, adăugând simboluri de debug în executabil, după care lansăm în execuție debugger-ul:

'''<span style="color: green">student@pracsis01</span> <span style="color: blue">~/Desktop $</span> gcc -g suma_fact.c -o suma_fact'''
'''<span style="color: green">student@pracsis01</span> <span style="color: blue">~/Desktop $</span> gdb suma_fact'''

<div class="regula">'''<font color="red"> Atenție:</font>''' Comanda de mai sus lansează în execuție numai debugger-ul, nu și programul ''suma_fact''.</div>
<div class="regula"> ''' Observație: ''' Putem observa că am pornit debugger-ul prin faptul că fiecare rând nou din linia de comandă începe acum astfel:</div>
'''(gdb)'''
Punem un ''breakpoint'' la linia 20, unde se citește valoarea lui n:
'''(gdb) b 20'''
'''Breakpoint 1 at 0x80484c2: file suma_fact.c, line 20.'''
'''(gdb) '''

Pornim programul în interiorul debugger-ului:
'''(gdb) run'''
'''Starting program: /home/student/Desktop/suma_fact'''
''' '''
'''Breakpoint 1, main () at suma_fact.c:20'''
'''20 scanf("%d", &n);'''
'''(gdb) '''
Trecem mai departe și introducem o valoare pentru n:
'''(gdb) next'''
'''Introduceti un numar natural mai mic sau egal cu 8: 6 '''
'''21 }while(n<0 || n>8);'''
'''(gdb) '''
Vom parcurge programul pas cu pas până la apelarea funcției ''factorial'':
'''(gdb) n'''
'''22 unsigned int suma = 0;'''
'''(gdb) n'''
'''23 for(i=0; i<=n; i++){'''
'''(gdb) n'''
'''24 suma += factorial(i);'''
'''(gdb) s'''
'''factorial (n=0) at suma_fact.c:4'''
'''4 if(n==0){'''
'''(gdb) s'''
'''5 return 1;'''
'''(gdb) s'''
'''13 }'''
'''(gdb) s'''
'''main () at suma_fact.c:23'''
'''23 for(i=0; i<=n; i++){'''
'''(gdb) s'''
'''24 suma += factorial(i);'''
'''(gdb) s'''
'''factorial (n=1) at suma_fact.c:4'''
'''4 if(n==0){'''
'''(gdb) s'''
'''8 unsigned int fact=0;'''
'''(gdb) s'''
'''9 for(i=1; i<=n; i++){'''
'''(gdb) s'''
'''10 fact *= i;'''
'''(gdb) s'''
'''9 for(i=1; i<=n; i++){'''
'''(gdb) s'''
'''12 return fact;'''
'''(gdb) print fact'''
'''$1 = 0'''
'''(gdb) '''
Observăm că valoarea returnată de funcția ''factorial'' pentru orice număr nenul este '''0'''. Acest lucru se datorează inițializării variabilei ''fact'' cu valoarea '''0''' la începutul funcției ''factorial''. Putem ieși din debugger pentru a modifica linia 8 din fișierul sursă suma_fact.c:
'''(gdb) q'''
'''A debugging session is active.'''
''' '''
''' Inferior 1 [process 4279] will be killed.'''
''' '''
'''Quit anyway? (y or n) y '''
'''<span style="color: green">student@pracsis01</span> <span style="color: blue">~/Desktop $</span>'''
<div class="regula"> ''' Observație: ''' Pentru a putea intra în interiorul funcției ''factorial'' este absolut necesar să se folosească comanda '''step''' și nu comanda '''next''' care ar trece peste acea linie 24 fără a intra în corpul funcției ''factorial''.</div>

După acest laborator veți putea folosi IDE-ul CLion pentru a scrie și depana programe în C. Totodată veți relua și recapitula noțiunile legate de pointeri în C.

= Utilizarea IDE-ului CLion =

[https://www.jetbrains.com/clion CLion] este un mediu integrat de dezvoltare (IDE) care permite dezvoltarea de programe în limbajele C și C++. CLion nu instalează și compilator pentru C/C++, acesta trebuie instalat manual, în prealabil.

<div class="regula"><span style="color: red; font-weight: bold">Atenție:</span> Imaginea de Linux folosită la Programarea Calculatoarelor are deja instalat compilatorul de C.</div>

== Instalarea GCC ==

=== Instalarea GCC în Linux ===

Pentru instalarea compilatorului de C (GCC) în distribuțiile de Linux provenite din Ubuntu (Ubuntu, Kubuntu, Xubuntu, Mint, LMDE, etc.) se poate folosi comanda:

apt-get install -y build-essential

=== Instalarea GCC în Windows ===

Pentru compilarea de programe cu GCC în Windows, aveți nevoie de instalarea acestui compilator care poate fi făcută prin instalarea unuia din următoarele două suite de programe:
* [https://cygwin.com Cygwin] - Tutorial de instalare [https://cygwin.com/install.html aici].
* [http://www.mingw.org/ MinGW] - Tutorial de instalare [http://www.mingw.org/wiki/InstallationHOWTOforMinGW aici].

<div class="regula"><span style="color: red; font-weight: bold">Atenție:</span> Nu uitați ca la instalare să bifați în lista de pachete și compilatorul de C (<code>gcc</code>), <code>make</code> și <code>git</code>.</div>

== Instalarea CLion ==

De la adresa https://www.jetbrains.com/clion/download/#section=linux puteți descărca kitul de instalare pentru sistemul vostru de operare.
După instalare, urmaţi următorii paşi de configurare, în funcţie de suita de programe aleasă:
* [https://www.jetbrains.com/help/clion/quick-tutorial-on-configuring-clion-on-windows.html#Cygwin Configurare CLion cu Cygwin]
* [https://www.jetbrains.com/help/clion/quick-tutorial-on-configuring-clion-on-windows.html#MinGW Configurare CLion cu MinGW]

== Realizarea unui proiect ==

Odată pornit, CLion oferă posibilitatea de a deschide un proiect existent, sau de a crea unul nou. Vrem să realizăm un proiect nou, aşadar se va alege '''New Project'''.

<div class="regula"> ''' Observație: ''' Se poate realiza un nou proiect atunci când altul este deja deschis folosind meniul <code>File - New Project </code> .</div>

[[Fișier:Welcome_to_clion.png | 600px | Imaginea 1]]

<br> Mai departe se va selecta categoria '''C++ Executable''' şi se va introduce locaţia proiectului.

<div class="regula"><span style="color: red; font-weight: bold">Atenție:</span> În imagine se observă că locaţia introdusă este '''/home/student/projects/NewProject'''. Se recomandă ca directorul în care se realizează proiectul să aibă numele proiectului, sau un nume sugestiv (în imagine '''NewProject''')</div>

[[Fișier:New_project_location_clion.png | 600px | Imaginea 2]]

== Componentele IDE-ului CLion ==

[[Fișier:CLion_env.png | 1000px | Imaginea 3]]

La crearea unui nou proiect, IDE-ul CLion generează automat fişierul '''main.cpp'''. Acesta conţine un exemplu program ce va fi rescris de către utilizator. <br>

Secţiunile marcate în imagine reprezintă:
# Zona <span style="color: green">verde</span> - '''Project view''' indică toate fişierele şi directoarele ce alcătuiesc proiectul.
# Zona <span style="color: blue">albastră</span> - '''Editor''' este fereastra de vizualizare şi editare a textului
# Zona <span style="color: red">roşie</span> - '''Toolbar''' oferă acces rapid pentru operaţiile uzuale. Dintre acestea, cel mai des vom folosi:
#*'''Build''' [[Fișier:CLion_build_button.png | 16px]]
#*'''Run''' [[Fișier:CLion_run_button.png | 16px]]
#*'''Debug''' [[Fișier:CLion_debug_button.png | 16px]]
# Zona <span style="color: gold">galbenă</span> - '''Run''' este zona în care se introduc datele de intrare şi se în care vor fi afişate datele de ieşire.

== Exemplu de program în modul ''debug'' ==

Copiați codul de mai jos înlocuind programul deja existent în fișierul ''main.c'':
<syntaxhighlight lang="C" line>
#include <stdio.h>

int main(){
printf("Debugging program...\n");
int value = 0;
value = value + 1;
value++;
value = value * 2;
value -= 1;
printf("Value is now %d!\n", value);
return 0;
}
</syntaxhighlight>

Pentru a executa programul în modul debug trebuie sa introducem cel puţin un '''breakpoint'''. Astfel indicăm programului unde se va opri pentru a ne acorda control asupra execuţiei, având posibilitatea de a continua execuţia pas cu pas. <br>

Introducem un nou breakpoint dând click în dreptul liniei de la care vrem să obţinem controlul. În cazul nostru, vom alege să indroducem un breakpoint chiar la definirea variabilei <code>value</code>.

[[Fișier:CLion_breakpoint.png | 1000px | Imaginea 4]]

<div class="regula"><span style="color: red; font-weight: bold">Atenție:</span> Când alegem locaţia unui breakpoint trebuie să ţinem cont de următorul aspect: în modul '''debug''' programul se va opri '''înainte''' de a executa linia în dreptul căreia a fost introdus breakpoint-ul!</div>

În continuare, trebuie se pornim execuţia programului in modul debug [[Fișier:CLion_debug_button.png | 16px]]. Observăm apariţia ferestrei Debug (chenarul albastru, Imaginea 5) ce conţine următoarele:
#Zona <span style="color: gold">galbenă</span> - fereastra cu toate variabilele declarate, împreună cu valorile lor. Momentan nu există nicio variabilă declarată (deoarece linia asupra la care ne-am oprit nu a fost încă executată!)
#Zona <span style="color: red">roşie</span> - Permite trecerea între fereastra pentru procesul de depanare ('''Debugger''') şi fereastra în care se afişează/introduc datele ('''Console''')
#Zona <span style="color: green">verde</span> - Conţine comenzile pentru controlul execuţiei în modul debug (comenzi numite '''stepping actions'''):
#*'''Step over''' [[Fișier:CLion_step_over.png | 16px]] - Execută comenzile de pe linia curentă şi trece la următoarea linie
#*'''Step into''' [[Fișier:CLion_step_into.png | 16px]] - Programul va executa linia curentă iar dacă pe linia curentă există un apel de funcție, se va opri pe prima linie din funcția respectivă. Această comandă este utilă atunci cand pe linia curentă se află un apel de funcţie şi vrem sa studiem comportamentul codului din interiorul funcţiei.
#*'''Step out''' [[Fișier:CLion_step_out.png | 16px]] - Termină de executat funcţia în care se află linia curentă
#*'''Run to cursor''' [[Fișier:CLion_run_to_cursor.png | 16px]] - Execută toate instructiunile până se intâlneste cursorul.

<div class="regula"> ''' Observație: ''' În modul debug, linia curentă este marcată de către mediul de dezvoltare prin colorarea acesteia cu albastru.</div>

Alte comenzi utile:
*'''Resume program''' [[Fișier:CLion_resume_project.png | 16px]] - Continuă execuţia pâmă la următorul breakpoint (dacă nu există, se va executa până la final)
*'''Stop''' [[Fișier:CLion_stop.png | 16px]] - Se opreşte definitv execuţia programului, împreună cu modul debug

[[Fișier:CLion_debug_process.png | 1000px | Imaginea 5]]<br>

Pentru a exersa utilizarea sistemului de debug, realizați următoarele operații:
# Parcurgeti tot programul folosind '''Step Over''' și vizualizând valoarea variabilei <code>value</code> la fiecare pas, până la ultima linie din program, unde utilizați '''Resume program'''.
# Reporniți aplicația în modul de debug și puneți un al doilea ''breakpoint'' pe linia cu apelul funcției <code>printf</code>.
# Folosiți '''Resume program''' pentru a ajunge la al doilea ''breakpoint''.
# Odată ajunși acolo, folosiți '''Step In''' pentru a intra în funcția <code>printf</code> (neavând codul sursă, veți vedea codul de asamblare obținut din dezasamblarea fișierului obiect de către GDB).
# Folosiți '''Step Out''' pentru a reveni în funcția <code>main</code> și apoi '''Resume program''' pentru a termina execuția.

== Tips & Tricks ==

=== Formatare automată a codului ===

CLion oferă opțiunea de a formata automat codul prin selectarea '''Code -> Reformat Code'''.

Ce probleme rezolvă această formatare automată:
* alinierea liniilor în funcție de blocurile de instrucțiuni și tipurile de ''statements'' de pe fiecare linie;
* plasarea sau eliminarea de spații acolo unde este necasar.
Ce probleme NU rezolvă această formatare automată;
* lipsa acoladelor de la blocurile '''if''' și '''for''';
* numele insuficient de sugestive pentru numele de funcții, structuri sau variabile.

Stilul conform căruia este modificat codul poate fi configurat folosind meniul <code>File|Settings|Editor|CodeStyle</code>

=== Generare automată a codului ===

CLion oferă posibilitatea de a genera fragmente de cod des înâlnite, precum constructori şi operatori în interiorul claselor. Această acţiune poate fi realizată folosind meniul <code> Code|Generate</code>.

=== Altele ===
* [https://www.jetbrains.com/help/clion/using-todo.html TODO Comments]

<br> Nu uitați de regulile următoare: [[Convenții de cod - C]]

Programare Orientată pe Obiecte (C++)

2026-02-20T07:33:13Z

Cbira: /* Tutorial Utilizare CLion IDE si debugger */

== Scopul laboratorului ==

Scopul laboratorului de Programare Orientată Obiect este de a introduce studentului conceptele paradigmei de programare orientată pe obiecte, aprofundarea limbajului C++, precum și familiarizarea cu tehnicile de programare specifice.

<div class="regula"><font color="#ff0000">Atenție:</font> Toate lucrările acestui laborator pleacă de la premiza că sunteți deja familiarizați cu sintaxa limbajului C.</div>

<div class="regula"><font color="#ff0000">Atenție:</font> Toate fișierele/ programele scrise la fiecare laborator se pot salva, pe e-mail, pe un stick USB, pe un repository personal de Git sau pe Moodle.</div>

== Platforme de laborator ==

# [[C++ POO Lab Lucrarea 1]] - recapitulare: pointeri și structuri
# [[C++ POO Lab Lucrarea 2]] - paradigme de programare; clasa, obiectul, câmpul și metoda; supraîncărcarea; constructorul; încapsularea și modificatorii de acces
# [[C++ POO Lab Lucrarea 3]] - destructorul; referința; metode ''const-qualified''; supraîncărcarea operatorilor; constructorul de copiere și operatorul de copiere prin atribuire
# [[C++ POO Lab Lucrarea 4]] - moștenirea; polimorfismul - metode virtuale și pur virtuale; clase abstracte
# [[C++ POO Lab Lucrarea 5]] - tratarea excepțiilor


== Tutorial Instalare g++ (Compilatorul C++ de la GNU) ==

=== Instalare Windows ===

Pentru Windows, compilatorul g++ poate fi instalat prin [http://www.mingw.org MinGW]. Urmăriți instrucțiunile de instalare și nu uitați să bifați compilatorul de C++ și utilitarul <code>make</code>.

=== Instalare Linux ===

Pentru Ubuntu, deschideți un terminal și tastați următoarea comandă:
<syntaxhighlight lang="bash">
sudo apt-get install build-essential
</syntaxhighlight>

== Tutorial Instalare CLion IDE ==

Pentru toate sistemele de operare, urmăriți instrucțiunile prezentate pe [https://www.jetbrains.com/help/clion/installation-guide.html site-ul oficial].

== Tutorial Utilizare CLion IDE si Debugger ==

[[C++ POO Lab Utile]] - utilizarea IDE-ului CLion și a debugger-ului

Programare Orientată pe Obiecte (C++)

2026-02-20T07:32:58Z

Cbira:

== Scopul laboratorului ==

Scopul laboratorului de Programare Orientată Obiect este de a introduce studentului conceptele paradigmei de programare orientată pe obiecte, aprofundarea limbajului C++, precum și familiarizarea cu tehnicile de programare specifice.

<div class="regula"><font color="#ff0000">Atenție:</font> Toate lucrările acestui laborator pleacă de la premiza că sunteți deja familiarizați cu sintaxa limbajului C.</div>

<div class="regula"><font color="#ff0000">Atenție:</font> Toate fișierele/ programele scrise la fiecare laborator se pot salva, pe e-mail, pe un stick USB, pe un repository personal de Git sau pe Moodle.</div>

== Platforme de laborator ==

# [[C++ POO Lab Lucrarea 1]] - recapitulare: pointeri și structuri
# [[C++ POO Lab Lucrarea 2]] - paradigme de programare; clasa, obiectul, câmpul și metoda; supraîncărcarea; constructorul; încapsularea și modificatorii de acces
# [[C++ POO Lab Lucrarea 3]] - destructorul; referința; metode ''const-qualified''; supraîncărcarea operatorilor; constructorul de copiere și operatorul de copiere prin atribuire
# [[C++ POO Lab Lucrarea 4]] - moștenirea; polimorfismul - metode virtuale și pur virtuale; clase abstracte
# [[C++ POO Lab Lucrarea 5]] - tratarea excepțiilor


== Tutorial Instalare g++ (Compilatorul C++ de la GNU) ==

=== Instalare Windows ===

Pentru Windows, compilatorul g++ poate fi instalat prin [http://www.mingw.org MinGW]. Urmăriți instrucțiunile de instalare și nu uitați să bifați compilatorul de C++ și utilitarul <code>make</code>.

=== Instalare Linux ===

Pentru Ubuntu, deschideți un terminal și tastați următoarea comandă:
<syntaxhighlight lang="bash">
sudo apt-get install build-essential
</syntaxhighlight>

== Tutorial Instalare CLion IDE ==

Pentru toate sistemele de operare, urmăriți instrucțiunile prezentate pe [https://www.jetbrains.com/help/clion/installation-guide.html site-ul oficial].

== Tutorial Utilizare CLion IDE si debugger ==

[[C++ POO Lab Utile]] - utilizarea IDE-ului CLion și a debugger-ului

2026-02-01T09:47:25Z

Cbira:

Dupa compilarea fiecarui modul c, urmeaza etapa de link-editare. Daca in timpul acelei etape linkerul nu gaseste o functie pe care o chemati, va afisa la consola o eroare de acest tip:

<pre>
Scanning dependencies of target untitled2
[ 50%] Building C object CMakeFiles/untitled2.dir/main.c.o
[100%] Linking C executable untitled2
CMakeFiles/untitled2.dir/main.c.o: In function `main':
/home/student/CLionProjects/untitled2/main.c:10: undefined reference to `sqrt'
</pre>

Acesta eroare se intampla asa cum se observa, nu la compilare (la consola se afiseaza Linking C executable ... si apoi eroarea "undefined referece to" respectiva functie => la linkeditare da eroare. Eroarea de mai sus este datorata faptului ca nu s-a inclus biblioteca math in procesul de linkeditare a executabilului. Pentru a o rezolva, trebuie indicat in reteta de build (fisierul CMakeLists.txt) adaugarea bibliotecii math.
<pre>
target_link_library(PROIECTUL_MEU m)
</pre>

Un exemplu de fisier CMakeLists.txt modificat se poate vedea mai jos:

[[Fișier:LinkMathLibCmake.png|faracadru|upright=2]]