Universitatea Politehnică Bucureşti

Facultatea de Electronică, Telecomunicaţii şi Tehnologia Informaţiei

Masini Virtuale

Student: Buculei Theodor Cristian

Iordache Florin Dorian

Grupa: 431A (CTI)

Anul universitar

2013-2014
Cuprins:
1. Introducere........................................................................................................pag. 3(Iordache F.)
1.1 Aspecte generale.... ....... ....... ....... ....... ...... .............................................pag. 3(Iordache F.)
1.2 Rulare simulatana a doua sisteme de operare...........................................pag. 4(Iordache F.)
1.3 Avantajele implementarii unei masini virtuale..........................................pag. 4(Iordache F.)
2. Procesul de instalare..........................................................................................pag. 5(Buculei Th.)
3. Masina Virtuala la nivel de proces......... ............... ............... ...........................pag. 8(Iordache F.)
4. Arhitectura Masinilor Virtuale bazate pe limbaje de nivel inalt.......................pag. 10(Buculei Th.)
4.1 Masina virtuala Pascal P-Code........ .......... .......... .......... ..........................pag. 11(Buculei Th.)
4.1.1 Arhitectura memoriei in P-code....................................................pag. 11(Buculei Th.)
4.2 Masini virtuale bazate pe limbaje orientate pe obiecte............................pag. 12(Buculei Th.)
4.2.1 Arhitectura masinii virtuale Java...................................................pag. 13(Buculei Th.)
4.2.1.1 Setul de instructiuni................................................................pag. 13(Buculei Th.)
4.2.1.2 Formatul instructiunilor..........................................................pag. 13(Buculei Th.)
4.2.1.3 Interfata nativa Java...............................................................pag. 14(Buculei Th.)
5. Implementarea Mașinii Virtuale......................................................................pag. 15(Iordache F.)
6. Virtualizarea resurselor ..................................................................................pag. 18(Iordache F.)
6.1 Procesorul.................................................................................................pag. 18(Iordache F.)
6.2 Memoria...................................................................................................pag. 19(Iordache F.)
6.3 Placa de retea – Ethernet Card.................................................................pag. 20(Buculei Th.)

7. Concluzii .............................................................................................................................pag. 22

8. Bibliografie...........................................................................................................................pag. 23
 1. Introducere
1.1 Aspecte generale
Masinile virtuale (Vmware si Virtualbox) fac posibilă rularea unui alt sistem de operare
intr-o "fereastră" a sistemului de operare principal, fără a repartitiona hard-disk-ul. Spre exemplu
pot rula un sistem de operare Linux intr-o fereastră a Windows-ului si invers.Este ca şi cum am
avea un alt calculator (virtual) pe care îl putem porni sau opri ca pe un program obişnuit.
Suportul pentru masina virtuală se instaleaza ca un program obisnuit iar dupa instalare, se
stabileste cat din sistemul real poate imprumuta masina virtuala (ex.memorie). Masina virtuala
contine un bios virtual, unde se alege de unde sa booteze.
Dupa pornirea masinii virtuale se poate boota de pe CD/DVD si se poate instala
sistemul de operare dorit. Se pot crea mai multe masini virtuale ce pot rula in acelasi timp.
Acestea se pot apoi sterge de pe hard-disk ca un director obisnuit cu fisiere.
Masinile virtuale functioneaza mai incet dacat un sistem de operare instalat direct pe
hard-disk ,dar nu se simte o diferenta notabila la utilizari obisnuite (Internet, Office, Muzica).
Maşina virtuală este un calculator imaginar, echipat cu un set de instrucţiuni ce reprezintă
limbajul virtual.
Modul de lucru in limbajul virtual se desfasoara in urmator mod: textul sursa este tradus
de catre compilator in limbaj virtual; programul rezultat reprezinta intrare pentru o procedura
numita executiv, care este de fapt un interpretor al codului virtual. Atributia executivului este
acela de a parcurge codul virtual obtinut de la compilator si de a rula fiecare instructiune, in
termenii limbajului masina al calculatorului tinta .
Beneficiul acestui mod de lucru este acela ca daca un limbaj sursa trebuie translatat in
mai multe limbaje obiect, compilatorul propriu-zis se scrie o singura data , iar pentru fiecare
limbaj obiect se face cate un executiv. Este mult mai usor sa se scrie un executiv decat sa se scrie
un compilator.Programul are o portabilitate crescuta deoarece codul generat in limbaj virtual
poate fi pus pe orice masina dotata cu interpretorul codului respectiv.
In principiu arhitectul compilatorului fixeaza codul virtual si arhitectura masinii virtuale,
dupa urmatoarele criterii:

 comenzile virtuale sa fie suficiente pentru a permite transpunerea corecta a instructiunilor

limbajului sursa;
 pentru fiecare limbaj obiect functionarea masinii virtuale sa poata fi cat mai usor de
simulat cu ajutorul executivelor.
De obicei, limbajul virtual este inspirat din limbajele de asamblare existente la un moment
dat, insa care au un grad ridicat de abstractizare.
Maşinile virtuale sunt utilizate în general pentru:

 multiplicarea maşinilor existente - Serverele, in general, rulează la niveluri joase ale

capacitatilor pe care le au. Din cauza acestui fapt se pot instala maşini virtuale ce pot
 satisface acelaşi necesitati ale utilizatorului ca şi serverul gazdă. Acest lucru reprezintă o
economie importantă de bani.
 testarea aplicaţiei ce urmeaza a fi lansată pe alte platforme.
 rularea unui anume tip de cod maşină. - Cel mai bun exemplu este Java Virtual Machine
ce permite rularea pe mai multe platforme a aplicaţilor scrise în limbajul Java.
Masinile virtuale ofera: posibilitatea de a rula simultan mai multe sisteme de operare pe
acelasi computer, pentru a testa diferite programe in medii diferite fara rebooturi pentru
cresterea securitatii in anumite medii, un exemplu fiind analiza virusilor fara riscul contaminarii
sistemului de baza (“host”) ,reducerea costurilor si cresterea eficientei energetice, prin folosirea
unui singur echipament fizic pentru rularea concomitenta a mai multor masini virtuale separate
solutii imbunatatite de disaster recovery.
Odata instalat un sistem de operare (Windows, Linux), care are driverele necesare, se poate
instala astfel un program de virtualizare (Vmware, Virtualbox),in care
se pot defini una sau mai multe masini virtuale iar in fiecare masina virtuala se poate instala cate
un sistem de operare. Masinile virtuale vor avea discuri virtuale, care vor fi stocate ca fisiere pe
disk-ul sistemului de operare principal, numit host (gazda). Sistemul de operare instalat in
masina virtuala va avea impresia ca are la dispozitie un hard-disk real.
Masinile virtuale consuma ceva spatiu pe disk, dar consuma memorie si procesor doar
daca sunt pornite. Masinile virtuale "tin minte" modificarile intre doua porniri, este ca si cum ai
reporni un calculator real. Cand nu mai este necesara masina virtuala, spatiul pe disk se poate
elibera usor stergand fisierele in care masina virtuala isi tine discurile virtuale.

1.2 Rulare simulatana a doua sisteme de operare

Consideram cazul in care rulam Windows7, dar avem un mic program care ruleaza doar
in WindowsXP. Putem porni un sistem WindowsXP in masina virtuala.
Sa consideram cazul in care am dori sa invatam Linux, dar in acelasi timp vrem sa avem
deschise programele obisnuite din Windows. Putem instala Linux intr-o masina virtuala care
ruleaza sub sistemul Windows.
Un alt caz ar putea fi testare unui sistem de operare nou aparut, fara a bloca accesul la
sistemul de operare instalat.
Se mai poate considera cazul in care o firma poate cumpara un calculator mai puternic pe
care sa existe mai multe masini virtuale, pe care angajatii sa faca teste in acelasi timp
(conectandu-se prin retea).

1.3 Avantajele implementarii unei masini virtuale

Backup foarte usor

Datorita faptului ca masinile virtuale sunt stocate in fisiere, backup-ul se face pur si
simplu copiind directorul masinii virtuale in alta parte. In momentul copierii masina virtuala
trebuie sa fie oprita.
 In general masinile virtuale suporta "snapshot-uri", in care este stocata starea instantanee
a masinii virtuale care ruleaza. Dupa un timp, masina virtuala se poate intoarce la acea stare.
Acest sistem consuma mai putin spatiu decat copierea intregii masini virtuale (se memoreaza
doar diferentele).
In cazul in care calculatorul s-a defectat sau a fost cumparat unul mai puternic, un back-
up al masinii virtuale se poate utiliza pe alt calculator. Cel putin la Vmware nu vor exista
probleme cu driverele diferita asa cum se intampla daca incercam sa mutam un hard-disk cu
Windows de pe un calculator pe altul.
Masina virtuala se poate opri cu programele deschise, iar la re-pornire va porni exact din
starea in care a fost oprita (cu toate programele deschise).
Intr-o firma se poate crea o masina virtuala cu tot ce este necesar unui angajat (programe
specifice, conexiuni VPN multiple) si sa o distribuie tuturor celor care au nevoie.

Portabilitate

Putem de exemplu sa avem acelasi sistem de operare si acasa si la

serviciu. Putem instala acel sistem de operare pe un stick USB sau pe un
hard-disk USB. Singura cerinta este sa existe in ambele parti instalat acelasi
program de virtualizare.Masinile virtuale pe USB functioneaza destul de
incet,de aceea se recomanda copierea pe hard-disk-ul local.
Probabil nu functioneaza in toate cazurile, dar o masina virtuala oprita se
poate intotdeauna repornii fara probleme pe alt hardware sau pe alt sistem
de operare.

2. Procesul de instalare

Aplicatiile de tip “Masina virtuala” au adus un suflu nou in lumea IT si au rezolvat o serie de
probleme introducand unele facilitati extrem de utile. Prima astfel de aplicatie a fost VMWare
Workstation si a aparut in 1999. De atunci, oferta de software-uri pentru virtualizare a crescut o
data cu performantele oferite de acestea. Majoritatea au si versiuni gratuite, mai mult sau mai
putin limitate comparate cu versiunile comerciale. Pe langa solutiile VMware, pe piata mai
putem mentiona Microsoft VirtualPC, Sun VirtualBox si Parallels Workstation.

Unul dintre marile avantaje oferite este faptul ca masinile virtuale pot interactiona la nivel de
retea: pe un singur sistem fizic, cu mai multe masini virtual, se pot crea mini-retele. In aceste
mini-retele se pot testa softuri, face analize pe marginea fiabilitatii si a breseloc de securitate
lasate de aplicatile testate, precum si orice alt gen de simulari.

In cele ce urmeaza, se va prezenta principalii pasi din procesul de instalare al unei masini
virtuale. O instalare corecta a masinii virtuale de la inceput inseamna timp si resurse castigate.
Pentru prezentare, se va folosi, in cele ce urmeaza, programul VirtualBox. VirtualBox este
gratuit pentru utilizare personala si evaluare (necesita achizitionare doar in cazul folosirii in
scopuri comerciale). Mai mult chiar, cei de la Oracle au lansat si o versiune Open Source, sub
licenta GPL, careia, insa, ii lipsesc cateva facilitati (suport USB, Remote Desktop, controller-ul
Serial ATA etc). VirtualBox, creat si dezvoltat initial de compania InnoTek a fost achizitionat de
Sun Microsystems in februarie 2008 si a devenit parte a platformei Sun de virtualizare,SunxVM.

Se va instala VirtualBox pe un sistem Windows (“host machine“) si apoi se va crea o

masina virtuala cu Ubuntu Linux (“guest machine“).
Pentru inceput se va downloada kit-ul VirtualBox de pe site-ul producatorului
(https://www.virtualbox.org/wiki/Downloads) si se trece la instalarea lui. Procesul de instalare
este de tip “user-friendly” si nu pune problem deosebite, toate setarile necesare fiind preselectate.
Singurul dezavantaj ce poate aparea este ca in timpul instalarii este posibila restartarea interfetei
de retea, ceea ce va lasa calculatorul gazda fara conexiune la retea cateva secunde.

Imediat dupa instalare, fara sa fie nevoie de reboot, utilizatorul este intampinat de
fereastra principala:

Din aceasta fereastra se poate incepe crearea noii masini virtuale. Se apasa “New”,
accesand astfel wizard-ul de configurare. Se da un nume masinii virtuale si alegem sistemul de
operare care va rula in aceasta masina (se activeaza astfel automat anumite setari in functie de
sistemul de operare guest, pentru o functionare optima a acestuia).
 Urmeaza selectarea dimensiunii memoriei RAM alocata masinii virtuale. Pe sistemul de
test avem instalati 2GB RAM si vom oferi 512 MB din acestia masinii virtuale Ubuntu Linux.
 Urmeaza crearea harddisk-ului virtual folosit de Linuxul guest. Acest harddisk virtual
este doar un simplu fisier in sistemul de operare host (Windows in cazul nostru). Virtualbox este
o o simpla interfata intre sistemul guest (Linux) care vede practic un harddisk si il trateaza ca
atare si sistemul de operare host (Windows) care vede un simplu fisier cu marime clar
determinata(cel putin initial). Implicit nu este creat nici un harddisk virtual, deci vom apasa
“New..” pentru crearea unuia (fiind posibila si utilizarea unui harddisk virtual creat anterior
pentru alta masina). In noul wizard aparut, trebuie aleasa o variant dintre cele doua tipuri de
harddisk virtual: cu crestere dinamica sau de marime fixa.

Harddisk-urile virtuale dinamice ocupa spatiu doar cat este necesar sistemului din masina
virtuala, acesta fiind alocat dinamic in functie de necesitati. Setarea cu dimensiune fixa permite
inca din momentul crearii harddiskului virtual alocarea intregului spatiu cerut. Este bine
cunoscut faptul ca, ulterior, se pot adauga unei masini virtual oricand si oricate harddiskuri este
nevoie.

Configuratia de baza a masinii virtuale create de wizard poate fi vazuta in orice moment.
De asemenea, aplicatia VirtualBox ofera si un buton Snapshots cu care se pot accesa diverse stari
ale masinii virtuale salvate anterior.

3. Masina Virtuala la nivel de proces

Un utilizator lucreaza  cu  un număr mare de programe  care ruleaza in acelasi timp într-

un mediu de sistem compus din una sau mai multe  procesoare, dintr-o memorie, dintr-un sistem
de fişiere, şi un număr de dispozitive periferice.
 Utilizatorul  interacţionează cu programele prin intermediul interfetei  susţinută 
de sistemul de operare şi de biblioteci. Un dezavantaj il reprezinta faptul că utilizatorul nu poate
rula alte programe in afara programelor care au  fost compilate pentru sistemul de operare
al utilizatorului şi setul de instrucţiuni ale procesorului . Una din aplicaţiile 
importante ale mașinii virtuale este aceea de a ocoli această restricţie şi a permite utilizatorului să
ruleze programe compilate pentru alte sisteme. Aşa cum  vom vedea,  un număr mare
de arhitecturi de tip VM (masina virtuala) pot  oferi această  capacitate, dar cea mai simplă 
abordare a VM ,din perspectiva utilizatorului, este de program oaspete dezvoltat pentru un alt
computer decât sistemul  gazdă al utilizatorului poate fi instalat şi utilizat în acelaşi mod ca
şi toate celelalte programe de pe sistemul gazdă; utilizatorul, precum şi alte programe
interacţionează cu  programul oaspete în acelaşi mod în care interacţionează cu programe
gazdă native.

Programele pentru calculator sunt compilate, distribuite, şi stocate ca fişiere

binare executabile care sunt conforme cu o interfaţă de aplicatie binară,  sau ABI,
care include caracteristici atăt ale setului de instrucţiuni hardware, cat şi ale  sistemului de
operare. De exemplu, un ABI utilizat pe scară largă este cel proiectat pentru a executa pe
un procesor de ce suporta Intel IA-32 ISA şi sistemul de oparare Microsoft Windows. Acum
câţiva ani, Intel a dezvoltat un nou procesor ISA , pe 64 de biţi, numit acum IPF, care
este implementat în familia deprocesoare Itanium. Programele de tip aplicație pe IA-32 nu vor
rula direct de pe platformele Itanium, chiar dacă sistemul de operare Windows a fost portat
pentru platformele Itanium.  Deci, pentru a permite utilizatorilor să
ruleze numărul mare de aplicaţii IA-32/ Windows pe platforme Itanium, cei de la Intel a
dezvoltat un mediu virtual IA-32/ Windows. Procesul de VM rezult, IA-32 EL (strat de
executie-execution layer), permite programelor IA-32 să apară unui utilizator Itanium exact
aşa cum ar aparea pe o platforma IA-32 nativa.  O altă versiune a procesului de IA-32 EL
VM cu o altă intrfață de sistem de operare este cea care suporta aplicatii IA-32/Linux.

Figura 1. ilustrează un mediu tipic de maşină virtuală de tip

proces. 
Cum se vede și în figură, software-ul runtime încapsulează, în esenţă, un proces oaspete
individual, oferindu-i acelaşi aspect exterior ca un proces nativ gazdă. Din punctul de vedere
al procesului oaspete, toate celelalte procese par să conforme cu viziunea  sa. Prin urmare, procesul
oaspete poate interacţiona cu procesele gazdă native în  acelaşi mod in care procesele gazdă
interacţionează intre ele. În plus, procesele oaspete pot interacţiona cu alte procese oaspete ca şi
cum acestea ar fi rulat pe o maşină reală.

4. Arhitectura Masinilor Virtuale bazate pe limbaje de nivel inalt

In mod conventional, o aplicatie compilata este strans legata de sistemul de operare si de
un set de instructiuni. Pentru executarea aplicatiei pe o platforma cu un sistem de operare diferit
si/sau alt set de instructiuni, este nevoie de recompilarea acestuia. Uneori, acest lucru implica
rescrierea anumitor librarii sau translatarea unor apeluri de sistem.

Pe langa portabilitate, setul de instructiuni al sistemului de operare virtual poate fi

construit astfel incat sa reflecte trasaturile specifice unui limbaj de nivel inalt. Astfel, pot fi
implementate eficient limbajele de nivel inalt, simplificand procesul de compilare prin separarea
compilatorului in portiuni dependente de sistem si independente de sistem. Deoarece, unul din
scopurile acestor masini virtuale este suportul eficient al limbajele de nivel inalt, sunt denumite
si high-level language virtual machines(HLL VMs).

O masina virtuala construita pe baza caracteristicilor limbajelor inalte (HLL VMs) este
similara unei masini virtuale bazata pe procese, dar in general, setul de instructiuni este definit
pentru programele ce ruleaza in modul utilizator. Prin urmare, pot fi executate numai pe un
procesor virtual. In consecinta, denumirea lor este seturi de instructiuni virtuale (V-ISA).
Interfata sistemului consta dintr-un set de librarii standard care pot, spre exemplu, sa acceseze
fisiere, sa comunice in retea si sa execute operatii grafice. Teoretic, masinile virtuale sunt
concepute sa suporte toate sistemele de operare, dar practic, trebuie sa le suporte macar pe cele
mai uzuale.

Se poate vizualiza masina virtuala din perspectiva limbajului/compilatorului in figura de

mai sus. Pasii pentru trecerea unui program de la limbajul de nivel inalt la cod masina, se
observa in figura (a). Compilatorul parseaza programul si il converteste intr-o forma
intermediara. Aceasta forma este preluata, optimizata, in unele cazuri, iar apoi este generat codul
obiect de catre compilator. Codul obiect este asemanator cu formatul seturilor de instructiuni, in
afara unor informatii simbolice, care sunt rezolvate in momentul incarcarii. In final, codul obiect
este convertit la o imagine de memorie, executata de procesorul hardware. In general, programul
este distribuit sub forma codului obiect, si poate fi rulat doar pe platformele compatibile cu
sistemul de operare si setul de instructiuni pe care a fost compilat. In cazul unei masini virtuale,
figura (b), compilatorul parseaza si converteste programul intr-un set de instructiuni virtual,
asemanator cu forma intermediara conventionala. Programul este distribuit in aceasta forma. In
momentul executiei, este convertit intr-o forma dependenta de implementarea masinii virtuale.
Optimizarile pot avea loc in procesul de emulare, ce presupune interpretarea si/sau translatarea
binara de la sistemul virtual la sistemul gazda. Cele mai importante componente ale
implementarii masinii virtuale sunt interpretorul/translatorul si componenta care se ocupa de
incarcarea programelor.

Un exemplu bine cunoscut de masina virtuala bazata pe limbajul de nivel inalt a fost
proiectata sa suporte limbajul Java. Programele Java sunt compilate in prima faza in clase Java
binare, care contin multe instructiuni codificate sub forma de secvente „bytecode” si „metadate”.
Masina virtuala Java (JVM) incarca apoi clasele binare si le executa. O alta masina virtuala, mai
recenta, CLI (common language infrastructure), face parte din cadrul Microsoft .NET.

4.1 Masina virtuala Pascal P-Code

Popularitatea limbajului de nivel inalt Pascal, s-a datorat masinii virtuale Pascal P-code,
deoarece a simplificat portarea compilatorului. Compilatorul parseaza programul Pascal si
genereaza codul-P, care reprezinta un set de instructiuni simplu, orientat spre expresiile de tip
stiva. Combinatia dintre un compilator Pascal si masina virtuala P-code reprezinta un compilator
Pascal complet si un sistem de executie pentru platforma gazda. Compilatorul este dezvoltat o
singura data si distribuit sub forma P-code, si portarea catre o noua platforma se reduce la
implementarea masinii virtuale. Acest procedeu este mult mai usor decat scrierea unui
compilator Pascal complet, de la zero. Masina virtuala P-code are doua mari componente:
emulatorul P-code, iar cea de-a doua este un set standard de librarii care comunica cu sistemul de
operare gazda pentru a implementa operatiile de intrare/iesire.

4.1.1 Arhitectura memoriei in P-code

Setul de instructiuni virtual P-code foloseste un model de memorie care consta dintr-o
zona de memorie a programului, o zona constanta, o stiva si o zona de memorie „heap” pentru
date. Un numarator de program aduce instructiunile din zona de program, altfel aceasta nu poate
fi citita sau scrisa. Figura de mai jos ilustreaza zonele de date din memorie. Toate zonele de date
sunt impartite in celule, iar fiecare celula poate retine o singura valoare. Dimensiunea unei celule
depinde de implementare dar trebuie sa fie suficient de mare pentru a stoca cea mai mare valoare
care poate fi specificata in codul-P. Compilatorul genereaza valorile din zona constanta. Acestea
reprezinta in mod obisnuit, operanzii folositi de program. O singura stiva actioneaza ca stiva de
proceduri, pentru a stoca informatiile de legaturi, parametrii si variabile locale, si ca stiva de
evaluare a operanzilor pentru executarea instructiunilor.

Zona de memorie „heap” este deasupra zonei constante si stocheaza structurile alocate
dinamic. Un nou pointer (NP) delimiteaza dimensiunea maxima a zonei „heap”. La apelul unei
proceduri, se aloca un nou cadru in stiva. Stiva este impartita in mai multe sectiuni vizibile in
figura de mai jos. Valoare returnata de functie, legatura statica si cea dinamica, si adresa de
intoarcere reprezinta o regiune de dimensiune fixa la inceputul cadrului din stiva, denumita
„mark stack”.

4.2 Masini virtuale bazate pe limbaje orientate pe obiecte

Un program contine cod independent de platforma si „metadate” dependente de sistem.
„Meta datele” reprezinta structurile de date, in general obiectele, atributele si relatiile dintre ele.
Dupa cum se observa in figura de mai jos, software-ul masinii virtuale este constituit dintr-un
emulator care poate interpreta sau translata codul in cod nativ. Arhitectura masinii virtuale
cuprinde, de asemenea, un modul de incarcare, ce converteste „meta datele” in structuri de date
specifice masinii gazda.
 In prezent cele mai promovate si utilizate masini virtuale (HLL VM) sunt „Java Virtual
Machine (JVM)” si „Microsoft common language infrastructure (CLI)”. Masinile virtuale
moderne se caracterizeaza prin diverse trasaturi sofisticate:

Securitate si protectie. Necesitatea securitatii apare, spre exemplu, la rularea programelor

din surse care nu prezinta incredere, cum ar fi Internetul, fara a compromite securitatea
sistemului local.

Robustete. Pentru dezvoltarea sistemelor software de scara larga, modelul programarii

orientate pe obiecte se potriveste foarte bine cu calculul distribuit si legaturile dinamice.

Comunicarea in retea. Componentele hardware de retea au latimea de banda limitata,

ceea ce favorizeaza programele care utilizeaza reteaua eficient. In consecinta, aplicatiile software
trebuie incarcate pe bucati, la cerere, utilizand legaturi dinamice.

Performanta. In timp ce indeplineste toate caracteristicile de mai sus, se doreste si

atingerea unei performante bune. In general, poate fi sacrificata o parte din performanta, dar o
masina virtuala buna trebuie sa faca parte dintr-un cadru complet care sa ofere utilizatorului o
buna performanta.

4.2.1 Arhitectura masinii virtuale Java

4.2.1.1 Setul de instructiuni

Java are un set de intructiuni de arhitectura orientat pe stiva, si poate fi asemanat cu setul
de instructiuni utilizat de P-code.

4.2.1.2 Formatul instructiunilor

Toate instructiunile contin un cod „opcode” si inca zero sau mai multi bytes. In figura de
mai jos se observa diverse formate de instructiuni. Fiecare camp al instructiunii contine exact un
byte, desi doua sau mai multe campuri pot fi concatenate pentru a forma un singur operand.
 Multe instructiuni au un singur byte, continand doar „opcode”-ul. In figurile (b) si (c) se
observa instructiuni ce contin codul op si un index format dintr-unul sau doi bytes. Octetii de
index sunt utilizati ca indici pentru plaja de constante sau pentru locatiile de stocare locala. O
alta clasa de formate de instructiuni este reprezentata de un „opcode” si unul sau mai multi bytes
de date, vizibile in figurile (d) si (e). Din cauza ca instructiunile sunt sub forma unor siruri de
bytes sau „opcodes”, indici, sau date, un set de instructiuni mai este denumit in mod generic
„bytecode”.

O proprietate de baza a setului de instructiuni Java este ca fiecare tip de primitiva are o
instructiune „bytecode” specifica. Spre exemplu, „opcode”-ul „iadd” (adunare de intregi) poate fi
folosit doar pentru operanzi intregi.

4.2.1.3 Interfata nativa Java

„Java native interface” (JNI) ofera posibilitatea codului java si a codului nativ compilat sa
interopereze. De exemplu, codul java poate apela o rutina compilata in C, si invers. Prin
utilizarea JNI, un program C are posibilitatea de a invoca o masina virtuala Java.

O vedere de ansamblu asupra JNI dar si asupra operatiilor sale se poate observa in figura
de mai jos. In partea stanga a imaginii, se observa arhitectura Java. Codul si datele compilate pe
o platforma nativa se afla in partea dreapta a imaginii. O observatie importanta este ca Java poate
fi compilat din orice limbaj unde exista un compilator care poate produce clase binare standard,
spre exemplu C#. Partea nativa poate fi compilata din C sau din orice alt limbaj pentru care
exista suport JNI, inclusiv limbaj de asamblare. Fiecare parte din figura de mai jos se compileaza
intr-un format binar propriu. Astfel, pentru java exista clasele binare standard, iar pentru partea
nativa, programe binare in codul nativ al platformei respective. Datele, in partea Java, exista sub
forma de obiecte si tablouri pe „heap” si variabile in stiva. In zona nativa, datele sunt organizate
de catre compilator intr-un mod oarecare, cu alte cuvinte sunt dependente de compilator.
 JNI ofera o interfata pentru metodele Java prin intermediul careia sa poata apela metode
native. Pentru aceasta, metoda nativa trebuie declarata „native” de clasa Java apelanta. Dupa
compilarea clasei Java in care este declarata metoda nativa ce va fi apelata, este utilizat
programul „javah” pentru a genera un fisier header pentru metoda nativa.

Controlul aplicatiei poate fi transferat intre codul Java si metodele native prin intermediul
interfetei native Java. Astfel pot fi transferate argumente si se pot returna valori. In ceea ce
priveste exceptiile prinse si aruncate de codul nativ, pot fi tratate de catre aplicatia Java. Pentru a
putea fi accesate datele din zona Java de catre codul din partea nativa, JNI ofera cateva metode
native. Spre exemplu, „GetArrayLength” va intoarce dimensiunea unui tablou Java, iar
GetIntArrayElements returneaza un pointer catre elementele unui tablou Java.

5. Implementarea Mașinii Virtuale

Blocurile majore de calcul si structuri de date ale unei VM de tip proces  sunt afişate

în Figura 2.
 Blocurile majore efectueaza următoarele funcţii:

Încărcătorul (the loader) scrie codul oaspete şi de date într-o regiune de memorie reținând

imaginea memoriei oaspete şi încarcă codul runtime. Deşi imaginea memoriei conţine codul
aplicație oaspete, precum şi date, din punct de vedere al runtime sunt toate date,deoarece codul 
sursă nu este direct executat.Mai degrabă, codul sursă este folosită ca input "date
" pentru interpretarea şi / sau a rutinelor de traducere binară.
Încărcătorul ofera apoi controlul blocului de iniţializare(initialization block), care alocă
spaţiu de memorie pentru codul cache şi alte tabele utilizate în timpul procesului de
emulare. Procesul de iniţializare invocă, de asemenea, sistemul de operare gazdă pentru a stabili
semnalele de taratare pentru toate condiţiile capcana care pot  apărea (cel puţin cele
pentru care semnalele sunt suporate de sistemul de operare). După iniţializare, procesul
de emulare(emulation) poate  începe,  de obicei folosind o serie tehnici de emulaţie într-
o manieră eşalonată.
Emulatorul folosește interpretarea şi / sau traducerea binară  pentru a
emula instrucţiunile clienţilor.Dacă traducerea binară este  folosită ca o metodă de
emulare, codul țintă tradus este ţinut într-un cod cache. Codul cache,care este scris de
către traducător,este o zonă de cod executabil în timp desfășurării emulării. Dacă emularea
se efectuează prin interpretarea cu o formă intermediară  predecodată,
instrucţiunile predecodate sunt stocate într-o structură similară cache.
Din cauza dimensiunii limitate a codului cache, managerul  codului cache este
responsabil pentru a decide care dintre traduceri ar trebui să fie eliminate din cache pentru a face
loc pentru noi traduceri care urmează să fie generate.
Bază de date de profil (profile database) conţine informaţii despre program,
dinamic colectate, care sunt folosite pentru a ghida optimizarea în timpul procesului de
traducere.
În timp ce emularea are loc şi programul oaspete efectuează un apel de sistem,
Emulatorul de apel catre SO (OS call emulator) traduce  apelul către sistemul de operare într-un 
apel adecvat (sau apeluri) la sistemul de operare şi apoi se ocupă de orice
informaţie asociată întoarsă ca urmare a apelului.
Runtime trebuie să se ocupe, de asemenea, de capcanele care pot apărea
ca urmare a executării fie a unei instrucţiuni de interpretare sau a unei instrucţiune
traduse, şi trebuie să se ocupe de orice intreruperi care sunt  îndreptate la procesul
oaspete. Runtime face acest lucru cu emulatorul de exceptii(exception emulator). În unele
cazuri, emulatorul de excepții intră în acțiune atunci când o capcana de emulare
declanşată cauzează semnalul către sistemul de operare să fie livrat la runtime; în alte
cazuri, rutinele de emulare descopera o condiţie de excepţie şi sare către emulatorul de
excepții . Un aspect important al tratării exceptiilor de runtime este generarea unei stări
de oaspete corecte, precise (inclusiv numărătorul de program,  valorile regiștrilor, şi condiţiile
de capcana) atunci când apare o condiţie excepţie.
 Tabele adverse( side tables), de exemplu, structurile de date generate ca
parte a procesului de traducere, sunt utilizate de runtime, ca parte a procesului de
emulaţie global. O utilizare importantă de tabele adverse este este în implementarea un model
precis de excepţii cu privire la sursa de ISA.
Instrucțiunile de emulare se poat face prin (1)interpretare, (2) traducere binară, sau (3) o
combinaţie pusă în scenă. Maparea adreselor şi protecţia memoriei poate fi făcută : (1) prin
intermediul unui tabel manageriat de runtime sau (2) folosind maparea directă.  Opţiunile cele
mai potrivite pentru o implementare dată depinde de  performanţă, complexitate, şi de
compatibilitate schimburilor (tradeoff).
Metoda cea mai generală de aplicare a emulației este folosirea interpretării de
instrucțiuni cu maparea software a memoriei şi verificarea protecţiei. Această
metodă adăposteşte compatibilitate intrinsecă,dar ar fi probabil cea mai lentă metodă
de emulare. Pe de altă parte, în cazul în care (1) Starea regiștrilor a clienţilor se
încadrează în fișierul de regiștrii gazdă,  (2) spaţiu de memorie oaspete încape în spațiul gazdă,
(3),  dimensiunea  paginii oaspeţilor este un multiplu al dimensiunii  paginii  gazdă, şi (4) tipurile
de privilegiu ale oaspeților sunt un subset al nivelurilor de privilegii ale gazdei,  apoi, în general,
traducerea binară cu  maparea hardware a adreselor şi verificarea sunt probabil cea mai rapidă
metodă de emulare, şi  de asemenea, este foarte probabil ca o compatibilitate intrinsecă sa
fi atinsă.
Condiţiile de mai sus par, inițial, să fie destul de restrictive;cu toate
acestea, unele cazuri practice importante îndeplinesc  aceste  constrângeri. Unul dintre
cazurile practice importante este de virtualizare de IA-32  ABI pe o
platformă RISC(sau un IPF Intel / platformă Itanium). În acest caz, de exemplu, IA-32 fişier de
registrii de obicei, se potriveşte confortabil în interiorul fişier de registrii gazdă, şi spațiul de
adrese al 32-bit IA-32 se potriveşte într-un spaţiu tipic de adrese pe 64 de biţi.
În multe alte situaţii, mașinile virtuale de tip proces pot fi construite pentru a
satisface constrângeri de compatibilitate extrinseci. Acestea oferă  doar  compatibilitate pentru
unii clienți binari, dar nu pentru toți. Compromisul cel mai important care trebuie să se producă
are loc atunci când gazda şi oaspetele suportă sisteme de operare diferite. În
acest caz, emulare a SO oaspete este probabil să fie incompletă. Acest lucru ar limita
aplicațiile la cele care depind de un subset de apeluri de sistem sau de
un subset de caracteristici ale SO.Indiferent de ce compatibilitate este satisfacută ar trebui
verificată pe program de baza echivalent, după toate probabilităţile.
Ce face ca masinile virtuale de tip proces sa iasă în evidență este punctul de
la care apelurile către sistemul de operare sunt interceptate şi emulaţia  se efectuează ~ pentru o
mașină virtuală de tip proces acest punct se află la interfaţa utilizatorului cu sistemul de operare.

6. Virtualizarea resurselor

6.1 Procesorul
 Aspectul cheie al virtualizarii procesorului consta in executia instructiunilor cloentului,
incluzand aici si instructiunile de la nivelul de sistem si cele de la nivelul user. Exista doua
moduri in care aceasta se poate realiza. Prima metoda este prin emulare. Emularea se poate
realiza fie prin interpretare, fie prin translatare binara. Emularea implica examinarea fiecarei
instructiuni in parte, fie in mod repetat pentru metoda interpretarii fie o singura data pentru
metoda translatarii binare. De asemenea, implica emularea pe resursele virtuale exact actiunile
care ar fi fost realizate pe resurse reale. Emularea este singurul mecanism disponibil de
virtualizare a procesorului atunci cand ISA clientului este diferit de ISA gazdei.

A doua metoda de virtualizare a procesorului foloseste executarea nativa directa pe

masina gazda. Aceasta metoda este posibila doar daca ISA gazdei este identica cu ISA clientului
si chiar si in acest caz doar in anumite conditii. Este oricand posibila construirea unei masini
virtuale folosind emularea, insa, chiar si cu tehnici sofisticate precum translatia binara,
performanta unui program pe masina virtuala va ajunge rar la performanta programului rulat pe
un hardware nativ.

Analiza originala facuta de Popek si Goldberg se referea la sisteme de generatia a treia,

precum IBM System/370, Honeywell 6000 si Digital PDP-10, dar ramane valabila si pentru
sistemele de astazi (desi din perspectiva ISA putem spune ca suntem inca in generatia a treia).
Presupunerile facute in analiza erau:

 Partea hardware este compusa dintr-un procesor si o memorie uniform adresabila

 Procesorul poate opera in unul din cele doua moduri(modul sistem si modul user)
 anumita parte din instructiuni este disponibila fie in modul sistem fie in modul user;
 Adresarea memoriei este facuta relativ la continutul unui registru de realocare (ex. O
valoare fixa este adaugata la o adresa virtuala pentru a ajunge la o adresa de memorie
fizica).

6.2 Memoria
Intr-un sistem de VM fiecare din clientii VM are propriul set de tabele de tabele de
memorie. Translatarea adresei din fiecare din VM clienti transforma adresel in adrese virtuale
catre locatii in memoria reala(memoria reala corespunde memoriei fizice pe o platforma nativa,
insa pe o platforma VM acest lucru nu se intampla). Intr-un sistem de VM, adresele din memoria
reala a clientului sunt mapate pentru a determina adrese din memoria fizica al hardwareului
gazda.

Memoria fizica este memoria hardware. Memoria reala este iluzia a memoriei fizice
perceputa de un client VM (aceasta iluzie este sustinuta de VMM care mapeaza memoria reala a
clientului la memoria fizica). Este aceasta mapare fizic-real cea care implementeaza virtualizarea
memoriei in tr-un sistem VM.
 Adaugarea unui alt nivel in ierarhia moemoriei duce la necesitatea unor mecanisme
aditionale pentru managementul memoriei. De notat este faptul ca marimea totala adunata a
tuturor clientilor este in general mai mare decat marimea memoriei fizice a sistemului. Astfel,
VMM mentine un spatiu de swap, distinct de spatiile de swap a fiecarui client. VMM
gestioneaza memoria fizica schimband paginile reale ale clientilor in si din propiul spatiu de
swap.

Asadar, trebuie facute anumite mentiuni cand vorbim de virtualizarea unui multiprocesor.
Trebuie luat in seama faptul ca atunci cand vorbim de un singur procesor, virtualizarea se face
prin time sharing-ul resurselor singurului procesor. Cu multiprocesor, virtualizarea se poate face
prin impartirea multiplelor procesoare intre sistemele virtuale. Optiunea dintre time sharing si
partitionare (sau folosirea amandurora) aduce alternative de design pe baza virtualizarii
multiprocesorlui.

Sistemele de VM s-au bucurat de o mare popularitate in ani 70 si 80, dar au parut ca se

sting spre anii 90 odata ce calculatoarele single-user au devenit mai ieftine si accesibile. Recent
s-a reinnouit interesul pentru sisteme virtuale, mai ales in partea de web, odata cu nevoia unui
numar masiv de sisteme simple single-thread (care tebuiesc foarte rar sa comunice intre ele dar
care impart resurse de stocare). Pentru aceste aplicati, masinile virtuale tind sa utilizeze resursele
procesorului in locul clusterelor mari de uniprocesoare. Masinile virtuale reduc in acelasi timp
costurile prin faptul ca a inchide sau a deschide o masina virtuala este foarte facil.

Desi popularitatea initiala a masinilor virtuale se datora abilitatii de a permite useri multiplii sa
foloseasca un sistem sofisticat ca si cum ar fi fost al lor, folosirea masinilor virtuale in viitor se
va datora altor factori. Exista probleme in curs de dezvoltare, cum ar fi securitatea şi incapsulare
de sistem, modele emergente, cum ar fi Grid, care vor spori gradul de utilizare a tehnologiei de
masini virtuale.

6.3 Placa de retea – Ethernet Card

In ceea ce priveste place de retea, sunt cateva aspecte de discutat( aspect bine tratate sip use
in practica prin driverul VirtualBox).

Unui sistem virtual ii putem adauga pana la 4 placi de retea virtuale (facilitate foarte utila
atunci cand dorim sa cream o retea virtuala cu mai multe sisteme virtuale conectate pe care sa
testam diverse lucruri). Fiecare placa poate fi intr-unul din urmatoarele moduri:

1. Not attached – placa de retea din sistemul guest nu va fi atasata sistemului fizic (deci nu
va putea accesa nimic practic din lumea reala, este doar prezenta si atat).
2. NAT – setare implicita – sistemul guest (Linux in cazul nostru) va putea accesa prin
placa de retea orice alt calculator fizic conectat la reteaua reala, sau Internetul, dar i se va
face Network Address Translation de catre VirtualBox (va avea astfel o adresa privata si
VirtualBox va actiona ca un router cu NAT pentru a translata aceasta adresa privata in
adresa IP de pe placa de retea fizica a sistemului nostru).
3. Host interface – acesta se mai numeste modul Bridged (in VMWare de exemplu). Astfel,
placa de retea virtuala este legata direct in placa de retea fizica, ca si cum ar intra ambele
intr-un switch. Astfel, are acces direct la reteaua noastra fizica ca si cum ar fi un alt
calculator conectat direct. Orice pachet trimis de sistemul guest, virtual, pe aceasta placa
va pleca direct pe placa de retea fizica si apoi in retea, orice pachet care intra in placa de
retea fizica si este destinat masinii virtuale ii va fi livrat acesteia in mod transparent.
Aceasta este cea mai simpla modalitate de a avea acces la retea din mediul virtual, dar
exista cazuri cand nu se poate aplica (daca PC-ul are alocat de la providerul de internet un
singur IP si nu exista un router intermediar, va fi nevoie de inca un IP de la provider,
simuland astfel existenta unui alt PC instalat la aceeasi conexiune Internet). Este bine de
stiut faptul ca daca PC-ul este intr-o retea cu IP-uri publice conectata la Internet in mod
direct, o masina virtuala cu Windows nou instalat va fi foarte vulnerabila datorita acestui
acces direct. Firewall-ul de pe sistemul fizic nu o va putea proteja.
4. Internal Network – pot fi create in VirtualBox mini-retele virtuale interne sistemului
fizic (le putem zice mini switch-uri) la care putem conecta dupa preferinta mai multe
masini virtuale pentru a putea interactiona intr-un mediu izolat.
 Si placa de retea emulata poate fi aleasa.Varianta elmulata, PCnet-FAST III, este destul de
buna, insa exista si variant Intel Gigabit. De altfel, pot fi selectate oricare din placile fizicee
existente pe PC-ul gazda.

In functie de nevoi se mai pot selecta crearea unor porturi seriale (util de exemplu daca dorim
sa accesam un port serial fizic din sistemul guest), accesul la device-uri USB, crearea unor asa-
numite “Shared Folders”, niste directoare pe sistemul fizic la care sistemul virtual va avea acces
direct precum si activarea facilitatii de Remote Desktop (prin care putem accesa oricare din
masinile virtuale existente prin remote desktop, de pe alt PC).

7. Concluzii
Trebuie facute anumite mentiuni cand vorbim de virtualizarea unui multiprocesor. Trebuie
luat in seama faptul ca atunci cand vorbim de un singur procesor, virtualizarea se face prin time
sharing-ul resurselor singurului procesor. Cu multiprocesor, virtualizarea se poate face prin
impartirea multiplelor procesoare intre sistemele virtuale. Optiunea dintre time sharing si
partitionare (sau folosirea amandurora) aduce alternative de design pe baza virtualizarii
multiprocesorlui.
Sistemele de VM s-au bucurat de o mare popularitate in ani 70 si 80, dar au parut ca se sting spre
anii 90 odata ce calculatoarele single-user au devenit mai ieftine si accesibile. Recent s-a
reinnouit interesul pentru sisteme virtuale, mai ales in partea de web, odata cu nevoia unui numar
masiv de sisteme simple single-thread (care tebuiesc foarte rar sa comunice intre ele dar care
impart resurse de stocare). Pentru aceste aplicati, masinile virtuale tind sa utilizeze resursele
procesorului in locul clusterelor mari de uniprocesoare. Masinile virtuale reduc in acelasi timp
costurile prin faptul ca a inchide sau a deschide o masina virtuala este foarte facil.
 Desi popularitatea initiala a masinilor virtuale se datora abilitatii de a permite useri multiplii
sa foloseasca un sistem sofisticat ca si cum ar fi fost al lor, folosirea masinilor virtuale in viitor
se va datora altor factori. Exista probleme in curs de dezvoltare, cum ar fi securitatea şi
incapsulare de sistem, modele emergente, cum ar fi Grid, care vor spori gradul de utilizare a
tehnologiei de masini virtuale.

8. Bibliografie:

1) notite curs SO( Stefan Stancescu)

2) http://en.wikipedia.org
3) http://www.cpushack.net
4) http://www.freebsd.org
5) Andrew Tanenbaum, Operating Szstems, Design and Implementation
6) http://en.wikipedia.org/wiki/Virtual_machine
7) http://en.wikipedia.org/wiki/Java_Virtual_Machine
8) Smith, James E. - Virtual Machines: Versatile Platforms for Systems and
Processes (The Morgan Kaufmann Series in Computer Architecture and Design)
9) http://www.techtorials.ro/2010/04/01/utilizare-masini-virtuale-vmware-
virtualbox
10) http://www.techtorials.ro/2009/03/22/virtualbox-instalarea-unei-masini-
virtuale