Responsabili:

• Darius Neațu (CA 2019-2021)
• Dorinel Filip (CA 2019-2021)
• Rareș Cheșeli (2018, 2017)

În urma parcurgerii acestui laborator, studentul va fi capabil:

• să înțeleagă conceptele legate de operații pe biți
• să utilizeze operații pe biți pentru optimizare (când este cazul)
• să înteleagă mai multe despre organizarea datelor în memorie
• să gestioneze mai bine memoria folosită într-un anumit program C
• să implementeze o structură de date in C

În cadrul acestui articol vă vom prezenta câteva metode prin care programele se pot optimiza dacă utilizăm eficient operaţiile pe biţi. Un lucru foarte important de reținut este că nu întotdeauna putem folosi aceste operații pentru optimizare, iar laboratorul are ca scop ilustrarea câtorva exemple, pe care le puteți întâlni și pe viitor.

Veți învăța în anul 2 la Analiza Algoritmilor despre complexitatea unui algoritm. Vom considera momentan că un algoritm este mai rapid decât altul dacă are mai puțini pași (exemplu un for cu n = 100 de pași este mai rapid decât un for cu 1000 de pași).

În exemplul anterior performanța se referă la timp (dacă executăm mai puține instrucțiuni într-un program, ne așteptăm să se termine mai repede). Acest aspect va fi abordat pe larg la materiile AA și PA.

În acest laborator vom vorbi despre altă metrică de măsurare a performanței unui program, mai exact despre memoria folosită de un program.

De ce este important și acest aspect? Dacă din punct de vedere al timpului de execuție, sunt situații în care putem aștepta mai mult timp pentru a se termina programul, din punctul de vedere al memoriei folosite avem o limitare exactă. Un exemplu simplu este calculatorul nostru, care are 4GB/8GB/16GB. Dacă mașina noastră are X GB RAM, dintre care o parte importantă o ocupă sistemul de operare, asta înseamnă că într-un anumit program nu putem folosi o cantitate nelimitată de RAM (mai multe detalii la CN2, SO). Pentru simplitate, momentan presupunem că programul nostru nu poate rula pe o mașină cu X GB, dacă are nevoie de mai mult de X GB.

Dacă ajungem într-o astfel de situație în mod evident trebuie să schimbăm ceva, însă de multe ori putem păstra algoritmul și să facem câteva modificări în implementare, care exploatează anumite abilități ale limbajului C (ex. operații pe biți).

În laboratorul 2 au fost prezentate tipurile de date implicite din C și dimensiunea acestora.

Pentru a afla dimensiunea în bytes a unei variabile se poate folosi operatorul sizeof.

#include <stdio.h>
 
int main() {
    // afiseaza dimensiunea tipurilor si a unor variabile de un anumit tip
    char xc;
    printf("sizeof(unsigned char) = %ld B\n", sizeof(unsigned char));
    printf("sizeof(char) = %ld B\n", sizeof(char));
    printf("sizeof(xc) = %ld B\n", sizeof(xc));
 
    short int xs;
    printf("sizeof(unsigned short int) = %ld B\n", sizeof(unsigned short int));
    printf("sizeof(short int) = %ld B\n", sizeof(short int));
    printf("sizeof(xs) = %ld B\n", sizeof(xs));
 
    int xi;
    printf("sizeof(unsigned int) = %ld B\n", sizeof(unsigned int));
    printf("sizeof(int) = %ld B\n", sizeof(int));
    printf("sizeof(xi) = %ld B\n", sizeof(xi));
 
    // afiseaza dimensiunea unor tablouri cu dimensiune cunoscuta
    char vc[100];
    short int vs[100];
    int vi[100];
    printf("sizeof(vc) = %ld B\n", sizeof(vc));
    printf("sizeof(vs) = %ld B\n", sizeof(vs));
    printf("sizeof(vi) = %ld B\n", sizeof(vi));
 
    return 0;
}

sizeof(unsigned char) = 1 B
sizeof(char) = 1 B
sizeof(xc) = 1 B

sizeof(unsigned short int) = 2 B
sizeof(short int) = 2 B
sizeof(xs) = 2 B

sizeof(unsigned int) = 4 B
sizeof(int) = 4 B
sizeof(xi) = 4 B

sizeof(vc) = 100 B
sizeof(vs) = 200 B
sizeof(vi) = 400 B

Operatorii limbajului C pot fi unari, binari sau ternari, fiecare având o precedenţă şi o asociativitate bine definite (vezi lab02).

În tabelul următor reamintim operatorii limbajului C care sunt folosiți la nivel de bit.

În C sunt definite doar shiftări logice. Acestea pot fi la stânga (<<) sau la dreapta (>>), reprezentând deplasarea in binar a cifrelor și completarea pozițiilor “golite” cu zerouri.

Având la dispoziție operațiile prezentate mai sus, putem răspunde la următoarele întrebări.

• Cum verificăm dacă bitul i dintr-un număr n este setat ?
• Cum setăm bitul i dintr-un număr n?
• Cum resetăm bitul i dintr-un număr n?

Pentru a răspunde ușor, pentru fiecare întrebare vom aplica o operație pe biți între n și o valoarea numită mască .

Checker laborator 7 CB\CD Teste Problema 1 Teste Problema 2 Teste Problema 3 Teste Problema 4 Teste Problema 5 Teste Problema 6

• Arhivele 4, 5, 6 testeaza reuniunea, intersectia respectiv diferenta seturilor.
• Intrarea corespunde functiei set_read (n, urmat de n elemente)
• Ref corespunde functiei set_print aplicata pe setul obtinut (cardinalul setului, urmat pe urmatoarea linie de elementele din set)

• Arhiva 7 corespunde problemei de bonus B1 (.ref contine rezultatul pentru get_lsb urmat de rezultatul pentru get_msb)
• Arhiva 8 corespunde problemei B2.

Rezolvați împreună cu asistentul pe tablă, exercițiile 0-4, apoi rezolvați invidual exercițiul 5.

Să se verifice folosind operații pe biți că un număr natural n e par.

int is_even(int n);

Să se scrie o funcție care să calculeze $2^n$, unde $ n <= 30 $.

int pow2(int n);

Răspundeți la întrebarea: are sens să scriem o funcție?

Să se scrie o funcție care să nege biții unui număr n (32 biți).

int flip_bits(int n);

Răspundeți la întrebarea: are sens să scriem o funcție?

Să se scrie o funcție care să afișeze toți biții unui număr întreg pe 32 biți.

void print_bits(int n);

Să se scrie o funcție care verifică dacă un număr întreg n pe 32 biți este puterea a lui 2. Funcția va returna 1 dacă n este putere a lui 2, 0 altfel.

int is_power2(int n);

Implementați invidual următoarea problemă.

O mulțime de numere întregi poate fi reprezentată astfel: spunem că un număr i aparține unei mulțimi S dacă bit-ul al i-lea din vectorul S are valoarea 1.

Pentru eficientă, vectorul S va conține date de tipul unsigned char (reamintim ca sizeof(unsigned char) == 1 byte adică 8 biți).

#define SET_SIZE 100                   // aceasta este o macrodefiniție (momentan o putem privi ca pe O CONSTANTA CARE ARE VALOAREA 100
typedef unsigned char SET[SET_SIZE];   // definesc tipul SET, care este un vector cu maxim 100 de elemente de tip unsigned char

Implementați următoarele funcții. Realizați un program în C prin care să demonstrați că funcțiile implementate funcționează.

• adăugarea unui element în mulțime

      // insert_in_set(s, n) - adauga numarul n in multimea s
      void insert_in_set(SET s, unsigned int n);
 

• ștergerea unui element din mulțime

      // delete_from_set(s, n) - scoate numarul n din multime s
      void delete_from_set(SET s, unsigned int n);
 

• verificarea faptului că un element n aparține unei mulțimi

      // is_in_set(s, n) - returneaza 1 daca n este in s, 0 altfel
      int is_in_set(SET s, unsigned int n);
 

• ștergerea tuturor elementelor din mulțime

      // delete_all_from_set(s) - elimina toate elementele din multime
      void delete_all_from_set(SET s);
 

• calcularea cardinalul unei mulțimi

      // card_set(s) - returneaza cardinalul multimii s
      int card_set(SET s);
 

• verificarea faptului că mulțimea este vidă

      // is_empty_set(s) - verifica daca multimea este sau nu goala
      // returneaza 1 daca este, 0 daca nu este
      int is_empty_set(SET s);
 

• o funcție care să citească de la tastatură o mulțime

      // read_set(s) - functia citeste numarul n de elemente care se afla in a
      // apoi citeste cele n numere si le insereaza in a
      // va returna numarul n citit (numarul de elemente)
      int read_set(SET s);
 

• o funcție care să afișeze pe ecran elementele care se află într-o mulțime

      // print_set(s) - functia printeaza elementele multimii s
      void print_set(SET s);
 

Urmăriți acest exemplu cu bitset pentru a înțele cum funcționeazăaceste operații.

Realizati un program care, utilizând metodele defite anterior, citește 2 mulțimi A (n și B și afișează: $ A U B, A ∩ B, A - B, B - A $.

Pentru a realiza acest lucru, va trebui să implementați următoarele funcții:

• reuniunea a două mulțimi (1p)

      // c = a U b
      void merge_set(SET a, SET b, SET c);
 

• intersecția a două mulțimi (1p)

      // c = a n b
      void intersect_set(SET a, SET b, SET c);
 

• diferența a două mulțimi (1p)

      // c = a \ b
      void diff_set(SET a, SET b, SET c);
 

În final va trebui sa creați o funcție main și să faceți un program care rezolvă cerința folosind funcțiile implementate.

O să învățați pe viitor că nu toate înstrucțiunile sunt la fel din punct de vedere al timpului de execuției. Ca un punct de start, gândiți-vă că dacă ați face pe foaie o adunare sau o înmultire, durează mai mult să înmulțiți decât să adunați. Această dificulate o are și procesorul din laptopul vostru!

Pentru a-l ajuta și a face programul mai rapid, putem înlocui operații costisitoare ( * , / ) cu altele mai puțin costistoare ( + , - ). Cele mai rapide instrucțiuni sunt cele care lucrează direct pe biți (deoarece numerele sunt stocate în memorie în binar, deci este modul natural de lucru pentru calculator).

Acest exercițiu vă propune să aplicați aceste optimizări pe codul vostru!

Să se scrie o câte o funcție pentru aflarea MSB(Most significant bit), respectiv LSB(Least significant bit), pentru un număr n pe 32 biți.

int get_lsb(int n);
int get_msb(int n);

Pentru cei interesați, recomandăm rezolvarea și următoarelor probleme, care sunt des întâlnite la interviuri.

      n = 5 și sirul [1, 4, 4, 1, 5]
      Numărul unic este 5. 

      n = 5 și sirul [1, 1, 4, 4, 4, 4, 5, 5, 5]
      Răspunsul este 5.
       

      n = 5 și sirul [1, 4, 4, 1, 5, 6]
      Numărele unice sunt 5 și 6. 

     n = 4, gramezi = [1 3 5 7], raspuns = NU
     n = 3, gramezi = [4 8 17],  raspuns = DA