Masini Virtuale - Andreea HONCIUC - Ingineria Sistemelor de calcul

Universitatea Politehnica Bucureşti
Facultatea de Electronică, Telecomunicaţii şi Tehnologia Informaţiei
Master Ingineria Informaţiei şi a Sistemelor de Calcul
Disciplina: Sisteme de operare avansate
Masterand IISC: Andreea HONCIUC
Maşini virtuale

Cuprins
INTRODUCERE ....................................................................................................................... 3
HAL (HARDWARE ABSTRACTION LAYER) ..................................................................... 4
CUM FUNCłIONEAZĂ HAL ? ..................................................................................................... 4
COMPONENTELE HAL ............................................................................................................... 4
MAŞINA VIRTUALĂ JAVA ................................................................................................... 5
COMPONENłA MAŞINII VIRTUALE JAVA ................................................................................... 5
CARACTERISTICI ....................................................................................................................... 6
ARHITECTURA MAŞINII VIRTUALE JAVA ................................................................................... 7
MEDIUL DE EXECUłIE................................................................................................................ 8
FORMATUL BYTECODE .............................................................................................................. 8
FIŞIERE DE TIP „.CLASS” .......................................................................................................... 10
CONSTRÂNGERI ALE CODULUI UTILIZAT DE JVM .................................................................. 10
VMWARE ............................................................................................................................... 12
APLICAłIILE VMWARE ........................................................................................................... 12
DISPOZITIVELE VMWARE ....................................................................................................... 13
VMWARE ESX SERVER ........................................................................................................... 16
VMWARE CONVERTER ............................................................................................................ 18
ÎMBUNĂTĂłIREA PERFORMANłELOR VMWARE ..................................................................... 18
X86 VIRTUALIZATION ........................................................................................................ 19
VIRTUOZZO .......................................................................................................................... 20
CARACTERISTICI ..................................................................................................................... 20
OPENVZ ................................................................................................................................... 21
COMPARAłIE ........................................................................................................................... 22
Z-MACHINE ........................................................................................................................... 22
O PRIVIRE ASUPRA STRUCTURII MAŞINII Z ............................................................................. 23
MAPAREA MEMORIEI ............................................................................................................... 25
BIBLIOGRAFIE ..................................................................................................................... 26
CĂRłI: ...................................................................................................................................... 26
SITE-URI DE INTERNET: .............................................................................................................. 26

Introducere
Maşina virtuală este un calculator imaginar, dotat cu un set de instrucţiuni ce constituie limbajul (codul)
virtual.
Lucrul cu cod virtual decurge astfel: textul sursă este tradus de către compilator în limbaj virtual;
programul rezultat constituie intrare pentru o procedură numită executiv, care este de fapt un interpretor al
limbajului virtual. Executivul este scris într-un limbaj recunoscut de calculatorul ţintă (cel pe care urmează să
ruleze programul compilat). Rolul executivului este acela de a parcurge codul virtual obţinut de la compilator şi
de a executa fiecare instrucţiune, în termenii limbajului maşina al calculatorului ţintă .
Avantajul acestui mod de lucru este acela că dacă un limbaj sursă trebuie tradus în mai multe limbaje
obiect, compilatorul propriu-zis se scrie o singură dată (el generează doar cod virtual), iar pentru fiecare limbaj
obiect se construieşte câte un executiv. A scrie un executiv este un lucru mult mai uşor decât a scrie un
compilator. Pe de altă parte, programul generat în cod virtual poate fi transportat pe orice maşină dotată cu
interpretorul codului respectiv, deci programul are o portabilitate crescută.
Un dezavantaj al lucrului cu cod virtual este acela că viteza de execuţie a programelor respective este
mai mică, deoarece ele sunt executate "software" (prin intermediul interpretorului) şi nu "hardware" (direct de
către procesor).
Limbajul virtual şi structura maşinii virtuale sunt stabilite în principiu de către proiectantul
compilatorului, după următoarele criterii:
• Comenzile virtuale să fie suficiente pentru a permite transpunerea corectă a instrucţiunilor limbajului
sursă;
• funcţionarea maşinii virtuale să poată fi cât mai uşor de simulat cu ajutorul executivelor, pentru fiecare
limbaj obiect.
În general, limbajul virtual este inspirat din limbajele de asamblare existente la un moment dat, având
însa un grad ceva mai mare de abstractizare.
Virtualizarea este un termen larg ce se referă la abstractizarea resurselor unui calculator. Este o tehnică
de ascundere a caracteristicilor resurselor unui calculator prin felul în care alte sisteme de operare, aplicaţii şi
utilizatorii interacţionează cu aceste resurse. Virtualizarea include crearea unei singure resurse fizice (server,
sistem de operare, hard disk), pentru a funcţiona ca multiple resurse logice sau invers (mai multe maşini fizice
formând una singură, o maşina virtuală).
Virtualizarea permite multiple maşini virtuale, cu sisteme de operare heterogene, să ruleze separat, una
lângă alta, pe aceeaşi maşina fizică. Fiecare maşină virtuală are propriul ei set de hardwere (RAM, CPU, NIC, etc)
pe care este încărcat un sistem de operare cu tot cu aplicaţii. Maşinile virtuale sunt încapsulate în fişiere, făcând
posibilă copierea şi salvarea rapidă a maşinii. Întregul sistem poate fi mutat în câteva secunde (sistemul de
operare, aplicaţiile, Bios-ul virtual, hardware-ul virtual).
Există două categorii de virtualizare: virtualizare pe platformă (implică simularea maşinilor virtuale) şi
virtualizare pe resurse (implică simularea combinării, simplificării sau fragmentării resurselor. Termenul de
virtualizare este o creaţie a maşinii virtuale, folosind o combinaţie între hardware şi software. Virtualizarea pe
platformă conţine o platformă hard şi un program de control.[2]

HAL (Hardware Abstraction Layer)
La nivelul superior, HAL este doar o cale de a permite unui număr de „blocuri de construcţie” să fie
încărcate si interconectate pentru a reuni un sistem complex. Partea „Hardware” este pentru că HAL a fost iniţial
conceput să uşureze configurarea EMC-ului pentru o plajă largă de echipamente hardware. Multe dintre
blocurile de construcţie sunt drivere pentru echipamentele hardware. Totuşi, HAL poate face mai mult decât
doar configurarea unor drivere de echipamente.
HAL se bazează pe aceleaşi principii care sunt folosite în proiectarea circuitelor şi sistemelor hardware,
deci se recomandă studierea acelor principii înainte. Orice sistem (incluzând un echipament CNC = computer
numerical control), constă în componentele interconectate. Pentru echipamentul CNC, acele componente pot fi
controller-ul principal, amplificatoare servo, motoare, codificatoare. Constructorul maşină trebuie să aleagă, sa
monteze şi să cableze aceste părţi pentru a realiza întregul sistem.
Cum funcŃionează HAL ?
Constructorul maşină nu trebuie să aibă grijă de fiecare componentă, luând-o ca atare. La nivelul de
proiectare, el decide ce componente va folosi. Decizile sunt luate în funcţie de ce face fiecare componentă şi de
specificaţiile furnizate de producător.
Proiectantul unui sistem hardware nu numai că alege componentele, dar şi decide cum vor fi
interconectectate acestea cu ajutorul unei schiţe ce arată toate legăturile.
De îndată ce schiţa este gata, se trece la constuirea maşinii. HAL posedă mai multe utilitare să ajute la
construirea sistemului. Unele dintre acestea permit conectarea/deconectarea unui singur fir, iar altele păstrarea
listei complete de componente, fire şi alte informaţii despre sistem, astfel încât să poată fi „reconstruit” printr-o
singură comandă.
Foarte puţine maşini funcţionează cum trebuie de prima dată. Pe durata testării, constructorul poate
folosi diverse aparate de măsura pentru a verifica parametrii de funcţionare. Este posibil să gaseasca o problema
care poate duce la schimbarea schiţei. HAL furnizează echivalente software pentru voltmetru, osciloscop,
generator de semnal şi alte utilitare pentru a testa si calibra un sistem.
Componentele HAL
1.3.1 Programe externe
- motion - un modul în timp real ce acceptă comenzi de mişcare NML şi interacţionează cu HAL.
- iocontrol - un modul de spaţiu al utilizatorului ce acceptă comenzi de I/O NML şi interacţionează cu HAL
- classicladder - un PLC (Programmable logic controller) care foloseşte HAL pentru toate I/O (intrări/ieşiri)
- halui - un program de spaţiu al utilizatorului ce interacţionează cu HAL şi trimite comenzi NML.[1]

1.3.2 Componente interne
- stepgen - generator de puls
- encoder - numărător codificator bazat pe software
- pid - bucle de control proporţionale/integratoare/derivatoare
- siggen - generator de testare a undelor sinusoidale / cosinusoidale / triunghiulare / pătratice
- supply - o simplă sursă de testare
- blocks - combinaţii de componente uzuale (mux, demux, or, and, integ, ddt, limit, wcomp)
1.3.3 Utilitare
- halcmd - utilitar cu linie de comandă pentru configurare si ajustare
- halgui - utilitar GUI (Graphical user interface) pentru configurare si ajustare (neimplementat incă)
- halmeter - un multimetru de mână pentru semnale HAL
- halscope - un osciloscop cu stocare digitală pentru semnale HAL [1]
Maşina virtuală JAVA
Limbajul Java reprezintă un limbaj de programare orientat pe obiecte, dezvoltat la origine de firma SUN
Microsystems şi devenit public în 1995 ca parte componentă a platformei Java dezvoltată de Sun. Sintaxa acestui
limbaj este asemănătoare cu a limbajelor de nivel înalt C şi C++, însă deosebirile dintre cele două sunt
importante.
Fundamentul platformei Java este dat de maşina virtuală, reprezentând mediul în care se execută
programele. Astfel, orice limbaj Java compilat, corect scris, poate fi rulat pe orice computer pe care e instalată o
maşină virtuală [4], independent de arhitectura acestuia. Acest lucru este posibil deoarece, în urma compilării,
sursele sunt transformate în bytecode, acesta reprezentând formatul standard intermediar între codul maşină şi
codul sursă.
ComponenŃa maşinii virtuale Java
Maşina virtuală Java poate fi împărţită în mai multe componente:
• ClassLoader: se ocupă cu aducerea fişierelor bytecode necesare execuţiei programului, fişiere ce se pot
găsi pe orice calculator dintr-o reţea dată;
• Bytecode Verifier: este utilizat pentru a verifica dacă fişierele de tip bytecode respectă setul de reguli
Java; fişierele ce nu sunt în concordanţă cu aceste norme sunt respinse;

• Interpreter + Java RunTime: se folosesc pentru analiza şi transformarea fiecărei instrucţiuni de tip
bytecode din cod maşină în instrucţiuni ale maşinii reale. Deoarece maşina virtuală Java constituie un
nivel suplimentar deasupra platformei de lucru (componente hardware şi sistem de operare) execuţia
programelor Java este mai lentă decât execuţia codurilor native;
• JIT (Just-in-Time): oferă ca soluţie pentru problema expusă anterior o executare a programului printr-un
compilator JIT ce transferă din primul moment programul Java în instrucţiuni ale procesorului, reuşind
astfel să crească viteza de execuţie a programelor;
• Garbage Collector: reprezintă componenta ce se ocupă de eliberarea zonelor de memorie alocate ce nu
mai sunt utilizate de program. Specificaţiile maşinii virtuale nu impun un algoritm de dezalocare, lăsând
stabilirea acestuia la latitudinea celui ce implementează aplicaţia. Cu toate acestea, deoarece în Java nu
îi este permis programatorului să aibă acces la resurse, de ocuparea şi eliberarea propriu-zisă se ocupă
mediul de execuţie;
• Security Manager: asigură respectarea restricţiilor de securitate impuse de lucrul cu sisteme deschise.
Arhitectura maşinii virtuale asigură un control foarte fin asupra acţiunilor pe care aplicaţia are voie să le
întreprindă în interiorul maşinii. Astfel, această parte este concepută pentru a asigura execuţia în
siguranţă a unui cod „nesigur” provenit din surse îndepărtate, caracteristică utilizată îndeosebi de către
applet-uri ce rulează pe maşini virtuale încorporate în browser-ele folosite de către utilizatori şi care
execută codurile descărcate de pe server-ele http de la distanţă.
Caracteristici
Maşina virtuală Java poate fi considerată un calculator abstract, dispunând, ca şi calculatoarele reale, de
un set de instrucţiuni, unul de registre şi diferite zone de memorie. Aplicaţiile scrise în Java nu sunt astfel
compilate pentru o platformă anume, ducând la o separare de platformă a limbajului. Nefiind impusă o
implementare anume, maşina virtuală se poate implementa ca interpretor de cod binar, compilator (generează
cod nativ), sau pe Siliciu, dar păstrând funcţionalitatea. Arhitectura JVM, este, ca a majorităţii maşinilor virtuale,
de tip stivă.
Această maşină virtuală foloseşte un bytecode obţinut, de obicei, din codul sursă al programului scris în
Java. Deoarece acest lucru nu este necesar, un JVM poate fi folosit şi pentru implementarea altor programe,
cum ar fi, de exemplu Ada. Pentru o securitate sporită, fişierelor cu extensia „.class” (bytecode-ul) li se impun
constrângeri importante, atât în ceea ce priveşte formatul, cât şi structura.
În paralel cu maşina virtuală, sunt distribuite o serie de librării care formează aşa-numitul Java API
(Application Programming Interface). Deoarece cele două componente trebuie să se susţină reciproc, ele sunt
încorporporate în Java Runtime Environment. Această structură este reprezentată în schema de mai jos:

Arhitectura maşinii virtuale Java
Structura Java Runtime Environment [5]
Maşina virtuală Java are o arhitectură de tip stivă, această structură fiind folosită pentru furnizarea
parametrilor pentru operaţii, preluarea rezultatelor, transferarea parametrilor metodelor ş.a.m.d. Ca şi în orice
alt limbaj si în Java stack frame-ul are o structură ce conţine 3 elemente: variabilele locale, mediul de execuţie şi
stiva de operanzi. În timpul apelării unei metode se va aloca spaţiu pentru variabilele locale şi mediul de
execuţie, în timp ce pentru stiva de operanzi schimbările vor surveni în timpul execuţiei.
Variabilele locale reprezintă un format stocat pe 32 de biţi, pentru valorile datelor reprezentate prin
tipuri de date long şi double fiind alocate câte două variabile locale. Aceste elemente sunt stocate într-un vector,
fiind adresate prin registrul „vars” şi încărcate cu ajutorul stivei de operanzi.
Mediul de execuţie este o componentă a ferestrei de stivă utilizată pentru păstrarea operaţiilor
efectuate aici. Ea conţine informaţii ce se folosesc la depanare, precum şi pointeri către fereastra de stivă
precedentă şi către baza şi vârful stivei de operanzi şi variabilele locale.
Stiva de operanzi funcţionează după principiul First-In-First-Out (FIFO) şi are dimensiunea de 32 de biţi.
Aici se stochează argumentele şi rezultatele obţinute în urma încărcării instrucţiunilor maşinii virtuale Java,
pentru fiecare tip de date putând fi utilizate numai operaţii specifice.
O importanţă deosebită o au şi clauzele „catch” conţinute în fiecare metodă din Java. Fiecare clauză se
ocupă de tratarea excepţiilor, aici fiind inclus domeniul pentru care este activă, tipul excepţiei tratate, precum şi

modalitatea de rezolvare a problemei. La aruncarea oricărei excepţii se va executa o căutare în lista „catch”,
corespondenţele fiind valide în cazul în care excepţia tratată este inclusă în domeniul în care este validă clauza,
sau dacă aceasta este derivată din excepţia tratată. Dacă cele două elemente sunt compatibile se vor executa
comenzile din blocul ce tratează excepţia, în caz contrar aceasta fiind aruncată la un nivel superior aceluia în
care a apărut. [1]
Mediul de execuŃie
Orice program ce se doreşte a fi utilizat de către o JVM trebuie compilat într-un format binar standard,
ce conţine extensia „.class”. Aceste programe pot conţine clase multiple aflate în fişiere diferite, de aceea este
preferată utilizarea arhivelor Java (fişiere „.jar”) pentru manevrarea programelor de dimensiuni extinse.
Deşi maşina virtuală Java a fost concepută la bază pentru rularea programelor Java compilate anterior şi
alte programe pot fi acum astfel rulate. [2] Printre aceste programe compatibile se numără Ruby (se utilizează
JRuby), JavaScript (cu Rhino) sau Phyton (cu Jytho). În prezent, Java are de asemenea implementat suport pentru
clasele şi metodele ce se modifică dinamic, lucru posibil însă numai în mediile de depanare.
Execuţia oricărui program se desfăşoară în jurul duratei de viaţă a maşinii virtuale, a claselor, interfeţelor
şi obiectelor care formează un program. Maşina virtuală porneşte execuţia în momentul în care este apelată
metoda „main” a unei clase prin trimiterea unui singur argument, sub forma unui şir de caractere. Astfel, clasele
utilizate sunt încărcate, iniţializate şi conectate cu celelalte tipuri folosite. Pentru acestea, metoda „main”
trebuie declarată public, static şi void (exemplu: public static void main(String Args[]) {}).
Încărcarea este efectuată de către ClassLoader şi subclasele conţinute de acesta. De asemenea, un rol
suplimentar al ClassLoader-ului este acela de a semnala erori din timpul încărcarii claselor prin aruncarea de
excepţii.
Conectarea are loc în urma încărcării şi foloseşte forma binară a unei clase sau interfeţe şi intercalarea în
procesul de rulare al maşinii virtuale. Activităţile implicate în procesul de conectare sunt: verificarea, pregătirea
şi analiza referinţelor simbolice.
Iniţializarea unei clase cuprinde executarea iniţializatorilor statici pentru câmpuri şi metode declarate în
clasă. Pentru interfeţe, iniţializarea cuprinde câmpurile din interfaţă. Înainte de acest proces, trebuiesc
iniţializate întâi superclasele, dar nu şi interfeţele implementate de clasa în discuţie. În mod similar,
superinterfeţele trebuiesc şi ele iniţializate înaintea interfeţei de bază.
Maşina virtuală Java îşi încheie activitatea atunci când se întâmplă unul din următoarele lucruri:
• toate thread-urile sunt terminate;
• unul din thread-uri invocă metoda „exit” a clasei Runtime sau System şi operaţia de ieşire este permisă
de către managerul de securiatate.
Formatul bytecode
Limbajul Java este considerat a fi un limbaj sigur, în sensul că nici un utilizator nu poate să afecteze
funcţionarea maşinii gazdă, să intervină într-un mod neadecvat în operaţiile efectuate de aceasta sau ca funcţiile
şi structurile de date ce aparţin codului „sigur” să nu fie afectate sau corupte de un cod considerat „nesigur” ce

ulează pe aceeaşi maşină virtuală. Mai mult, se consideră că se poate împiedica apariţia erorilor comune de
programare, cum ar fi depăşirea dimensiunilor unui array sau folosirea de pointeri neiniţializaţi, care duc la un
comportament neprevăzut al compilatorului sau la afectarea datelor existente.
Pentru a evita aceste probleme, maşina virtuală Java verifică bytecode-ul înainte de execuţie, verificare
ce se desfăşoară în 3 paşi:
• toate variabilele indică locaţii valide din memorie;
• datele sunt întoatdeauna iniţializate;
• accesul la datele declarate „private” este strict controlat.
Primele două din aceste etape au loc în timpul pasului de „verificare”, care are loc atunci când o clasă
este încărcată şi gata pentru a fi folosită. Cel de al treilea pas se efectuează în mod dinamic, atunci când datele
sau metodele unei clase sunt pentru prima oară accesate de o altă clasă. Această verificare impune anumite
restricţii asupra programelor valide, cum ar fi cele ce afectează instrucţiunile de salt care pot face referire numai
la funcţii din aceeaşi funcţie sau metodă. De asemenea, verificarea bytecode-ului oferă siguranţa că modelele
arbitrare de biţi nu se pot folosi ca şi adrese valide. Astfel, protecţia memoriei este asigurată fără utilizarea unei
MMU (Memory Management Unit), iar JVM-ul devine o metodă eficientă pentru protecţia memoriei chiar şi pe
arhitecturi simple.
Aşa cum s-a precizat, bytecode-ul reprezintă tipul de instrucţiuni pe care maşina virtuală Java poate să îl
execute, reprezentând echivalentul de limbaj de asamblare a unei aplicaţii Java. La fel ca orice aplicaţie C,
rezultatul obţinut în urma compilării este un cod binar, cu deosebirea că aici nu este strâns legat de un
microprocesor.
Instrucţiunile Java sunt formate dintr-un opcode şi operanzi. Opcode-ul are lungimea de un octet, în
timp ce operandul este de lungime variabilă. Cu toate acestea, nu toate cele 256 de instrucţiuni posibile sunt
utilizate, existând un anumit număr ce sunt mereu libere. [5] Operanzii cu lungimi mai mari de un octet se vor
păstra în memorie folosind modelul „big endian”, în care octetul cel mai semnificativ este primul.
Operanzii din memoria de date a JVM-ului sunt prelucrate de instrucţiunile binare Java ca aparţinând
unui grup redus de tipuri primitive. Aceste tipuri de date primitive pot fi: byte, short, int, long, char, floar, double
sau boolean. Ele sunt tratate de către compilator şi nu de programul Java compilat sau mediul de execuţie Java,
instrucţiunile Java conţinând cod operaţie separat pentru diferitele tipuri de date primitive.
Maşina virtuală Java conţine instrucţiuni pentru următoarele grupuri de sarcini:
• operaţii aritmetice;
• conversii;
• încărcare şi înmagazinare;
• crearea şi manipularea de obiecte;
• controlul stivei cu operanzi;
• controlul transferurilor;
• apelarea metodelor şi elementele returnate;
• aruncarea de excepţii;

Toate aceste reprezentări binare au ca scop compatibilitatea între sisteme, deoarece fiecare sistem de
operare de pe unităţile de prelucrare are nevoie de versiunea proprie de JVM. Aceste maşini virtuale
interpretează însă bytecode-ul similar din punct de vedere semantic, deşi implementările pot să difere de la caz
la caz. Un caz mai special decât cel legat de portabilitatea bytecode-ului este dat de implementare eficientă a
Java API, care trebuie sa fie în concordanţă cu cerinţele fiecărui sistem de operare.
Din punctul de vedere al unui compilator, bytecode-ul reprezintă doar un alt tip de procesor cu un set de
instrucţiuni care poate trata codul generat. Astfel, deşi maşina virtuală Java a fost iniţial concepută pentru a
executa programe scrise în limbajul Java, aceasta oferă un mediu de execuţie în format bytecode îndeajuns de
dezvoltat pentru a suporta compilări ale programelor scrise în alte limbaje.
Fişiere de tip „.class”
În urma compilării, fişierul ce trebuie executat de către maşina virtuală Java este reprezentat utilizând
un format binar hardware şi independent de sistemul de operare, gasit de obicei în fişiere cu extensia „.class”.
Acest format defineşte în mod precis şi detaliat reprezentarea unei clase sau a unei interfeţe. [3]
Constrângeri ale codului utilizat de JVM
Codul maşinii virtuale Java pentru o metodă, metodă de iniţializare a instanţelor, sau metode de
iniţializare a claselor şi metodelor sunt localizate în structura method_info a unui fişier „.class”. Constrângerile
care sunt asociate cu conţinutul structurii Code_attribute se împart în două categorii: constrângeri statice şi
constrângeri structurale. [6]
Constrângerile statice asupra unui fişier de tip „.class” sunt acelea care definesc corectitudinea
formatului acestui tip de fişier. Aceste constrângeri impuse asupra codului din maşina virtuală Java arată
structura instrucţiunilor maşinii virtuale şi operanzii ce vor fi folosiţi pentru fiecare instrucţiune.
Din constrângerile legate de instrucţiunile aflate în vectorul de instrucţiuni şi operazi putem aminti:
• Valoarea elementului code_legth nu poate fi 0 şi trebuie să fie mai mică decât 65536;
• Opcode-ul primei instrucţiuni din tabloul code are întotdeauna indexul 0;
• Pentru fiecare instrucţiune din vectorul de instrucţiuni, cu excepţia ultimeia, indexul opcode-ului
următoarei instrucţiuni trebuie să fie egal cu indexul opcode-ului de la instrucţiunea curentă la care se
adaugă lungimea instrucţiunii în discuţie, incluzând toţi operanzii;
• Registrul la care face referire o instrucţiune de salt trebuie să fie un opcode al unei instrucţiuni din
aceeaşi metodă;
Constrângerile structurale coordonează relaţiile dintre instrucţiunile maşinii virtuale Java. Dintre
acestea putem menţiona:
• Fiecare instrucţiune trebuie executată în funcţie de tipul şi numărul de argumente din vectorul
variabilelor locale. Cu toate acestea, o instrucţiune ce operează asupra unei valori de tip int poate să

prelucreze şi date de tipul boolea, byte, char şi short, deoarece maşina virtuală Java converteşte
automat aceste tipuri la tipul int;
• În timpul execuţiei nu se poate schimba ordinea dintr-o pereche de variabile locale ce conţin elemente
de tip long sau double;
• Nici o variabilă locală nu poate fi accesată înainte de iniţializare;
• Înaintea accesării unei metode sau instanţe a unei variabile, instanţa clasei ce conţine metoda sau
variabila trebuie să fi fost deja iniţializată;
• La apelul unei metode, argumentele utilizate trebuie să fie compatibile cu tipul utilizat în descrierea
metodei;
• Fiecare element returnat trebuie să aibă tipul specificat în descrierea metodei. Toate metodele de
iniţializare, fie ele pentru clase sau interfeţe, sau metodele ce returnează void trebuie să utilizeze numai
instrucţiunea „return”. Pentru metodele ce returnează date de tip boolean, byte, char, short sau int se
foloseşte instrucţiunea „ireturn”, în timp ce pentru metode ce returnează o referinţă la obiect se va
utiliza „areturn”;
• Nici o valoare de tipul returnAddress nu poate fi accesată folosind o variabilă locală.
În fişierele de tip „.class” se mai întâlnesc următoarele limitări:
• În rezerva de constante (constant pool) asociate fiecărei clase Java se va păstra numele tuturor
câmpurilor, metodelor şi informaţiile ce pot fi utilizate de orice metodă a clasei. Această rezervă se
comportă ca o limitare internă a complexităţii clasei sau interfeţei create, deoarece dimensiunea ei nu
poate depăşi 65535 de instrări;
• Numărul de câmpuri ce pot fi declarate în interiorul unei clase sau interfeţe este limitat la 65535 de
către valoarea elementului „fields_count”. Această valoare nu include însă câmpuri moştenite de la
superclase sau superinterfeţe;
• Numărul de metode ce pot fi declarate într-o clasă sau interfaţă este dat de valoarea maxima de 65535 a
valorii lui „methods_count” din structura ClassFile, în această valoare nefiind incluse metodele
moştenite;
• Numărul de superinterfeţe sau de superclase este şi el limitat de aceeaşi valoare (65535) prin valoarea
maximă a elementului interfaces_count;
• Într-o metodă, numărul parmetrilor este limitat la 255 în definirea descriptorului metodei, în această
limită fiind inclus un loc şi pentru cuvântul cheie „this”, în cazul în care se invocă o instanţă sau interfaţă
a respectivei metode. Descriptorul metodei este definit în funcţie de dimensiunea parametrilor, astfel că
limita se reduce în cazul utilizării tipurilor long sau double cărora le sunt alocate două unităţi;
• Lungimea numelor câmpurilor şi metodelor, descriptorilor de câmpuri şi metode sau alte string-uri cu
valoare constantă trebuie să aibă dimensiuni mai mici de 65535 de caractere datorită dimensiunii pe 16
biti a elementului length din structura CONSTANT_Utf8_info. Limita este de fapt impusă asupra
numărului de octeţi si nu asupra numărului de caractere codate, de aceea string-urile ce conţin
caractere codate pe mai mulţi octeţi sunt supuse unor limitări mai importante.

VMware
VMware este o maşina virtuală ce permite accesul la sisteme de operare diferite de sistemul de operare
nativ. Spre exemplu pe o platformă hardware ce rulează sistemul Windows XP se poate rula simultan un alt
sistem de operare cum ar fi Linux sau o altă versiune de Windows.
VMware se bazează pe o arhitectură de tip Pentium (sau superioară acesteia) şi este disponibilă pentru
sistemele de operare: Windows NT, Windows 2000, Windows XP şi Linux. Maşina virtuală funcţionează pe o
platformă hardware reală copiind arhitectura acesteia. Astfel dacă avem la dispoziţie o arhitectură Intel Core 2
atunci maşina virtuală va prelua toate elementele acesteia (setul de instrucţiuni, accesul la memorie etc.) şi nu
va funcţiona ca un alt tip de arhitectură Pentium.
Ca principiu de funcţionare maşina virtuală VMware se comportă asemănător unui emulator însă cu
câteva diferenţe majore. Emulatorul se bazează pe resurse software interceptând şi interpretând instrucţiunile
maşinii client pe când VMware interceptează şi transmite platformei hardware reale instrucţiunile. Rezultă de
aici mai multe avantaje printre care cele mai importante sunt viteza de lucru mai mare şi reducerea probabilităţii
de apariţie a erorilor. Creşterea vitezei este rezultatul direct al modului în care sunt tratate instrucţiunile. Dacă
la emulator acestea sunt tratate la nivel software la VMware acestea sunt preluate de hardware-ul maşinii
gazdă. Sunt astfel diminuate şi sansele de a apărea erori întrucât procesorul gazdei are mult mai puţine şanse să
genereze erori decât o aplicaţie software. Totuşi, viteza de lucru a sistemului client este mai scazută decât a
sistemului gazdă întrucât este nevoie de timp pentru a comunica între hardware-ul virtual şi cel real.[7]
AplicaŃiile VMware
Una dintre cele mai importante întrebuinţări ale VMware este aceea de a testa noile sisteme de
operare. În principiu, pentru testarea unui sistem de operare este nevoie de un calculator fizic, fiind nevoie ca
pentru orice modificare în nucleu (kernel) să se facă o restartare a întregului sistem. Testarea pe un alt calculator
este iarăşi o soluţie consumatoare de timp fiind permanent nevoie de a se copia informaţiile de pe o maşină pe
alta. VMware elimină această necesitate întrucât noul sistem poate fi rulat pe acelaşi calculator, împărţind
acelaşi mediu de stocare fizic cu maşina pe care este dezvoltat. Datele pot fi astfel transferate foarte uşor,
depanarea este mult mai facilă întrucât VMware pune la dispoziţie unele instrumente specifice (Snapshot
Record) precum şi un disc de revenire în caz ca sistemul client cedează pentru a-l readuce la setările iniţiale.
VMware este folosit de asemenea şi la simularea şi testarea retelelor, acestea putând fi create la nivel
virtual fără cabluri sau terminale fizice. Se pot stabili legături de tip client-client sau client server între gazdă şi
sistemul de operare găzduit. Toate setările pot fi efectuate de pe un singur calculator şi se pot testa oricâte
conexiuni simultane fără posibilitatea de supraîncărcare şi apariţie a fenomenului de bottleneck la nivelul
reţelei. [7]

Dispozitivele VMware
1. Magistralele
Sunt trei dispozitive de bază pe care VMware le simulează. Ca la orice sistem de calcul acestea sunt:
procesorul, memoria şi dispozitivele Input/Output. La un calculator obişnuit procesorul este conectat de restul
componentelor prin intermediul magistralelor (bus), acest lucru fiind necesar să fie implementat şi pentru
maşina virtuală. VMware are două magistrale virtuale, prima dintre ele cu o funcţionare similară modelului PCI,
iar cea de-a doua denumită PCI-to-ISA bridge. ISA este un standard hardware vechi, provenit de la sistemele
IBM, la care s-a renunţat din cauza unor limitări ale acestuia. Una dintre limitări ţine de controlul întreruperilor.
Dispozitivele trimit cereri de întreruperi prin magistrală către UPC. Acesta îşi încetează activitatea şi procesează
întreruperea. ISA numerotează aceste întreruperi (IRQ) pentru a le diferenţia. Din păcate pentru ISA nu sunt
foarte multe numere, iar atunci când apare situaţia în care două întreruperi poartă acelaşi numere, rezultă
conflicte grave. Acest lucru este rezolvat de PCI care nu are numere fixe pentru întreruperi, iar întreruperile PCI
poartă mai multă informaţie astfel încât într-o singură întrerupere PCI şi mai multe dispozitive pot împărţi
acelaşi IRQ.
SCSI
SVG
A
Magistrala PCI
Ethernet
VMware – hardware real si virtual [1]
În figură, partea virtuală este încadrată în chenarul punctat. Se observă foarte bine cum dispozitivele
sunt conectate la UCP prin intermediul magistralei PCI şi a PCI-to-ISA bridge şi a interfeţelor acestora.
2. Discurile IDE şi CD-ROM
UPC
IDE Sunet Altele
PCI-to-ISA bridge
MMU
Memorie
VMware posedă două controllere IDE (Integrated Device Electronics) numite primar şi secundar.
Hardware-ul virtual pentru acestea este chipsetul Intel 82371AB PIIX3 având porturile IRQ asignate ca în tabelul
de mai jos:

Interfata IRQ Porturile I/O
Primar 14 0x01f0 – 0x01f7, 0x03f6
Secundar 15 0x0170 – 0x0177, 0x0376
Ca orice interfaţă IDE aceste porturi pot suporta maximum două dispozitive (numite master şi slave),
fiind limitate în cazul VMware la discurile CD-ROM/DVD-ROM, CD-R şi CD-RW care pot fi configurate în mai
multe moduri. Aceste discuri sunt stocate pe suportul hardware real sub formă de imagini virtuale, ocupand o
parte din spatiul discului real. Un disk “raw” este o mapare a discurilor sistemelor gazdă ce poate fi folosită sub
VMware. Un avantaj al acestor discuri virtuale e că se pot manipula mult mai uşor şi se pot folosi imagini virtuale
de pe sistemul gazdă. [14]
3. Discurile SCSI (Small Computer System Interface)
SCSI e un standard de magistrală folosit la calculatoarele personale, independent de arhitectura
acestora. Un astfel de hardware virtual foloseşte şi VMware care poate suporta până la 60 discuri virtuale, faţă
de 15 cât poate suporta o magistrală SCSI reală şi foloseşte un cotroller LSI Logic LSI53C10xx Ultra320 SCSI I/O.
Modul de funcţionare al interfeţei SCSI este asemănător cu cel al IDE, fiind tratată ca un dispozitiv PCI şi având
numerele IRQ şi porturile alocate dinamic la fiecare pornire.[14]
4. Discurile Floppy
În VMware se pot configura 2 discuri floppy ca mapări ale discurilor reale de pe sistemul gazdă. Acestea
se pot accesa atât de pe sistemul gazdă cât şi prin intermediul VMware. Controllerul floppy are IRQ 6 cu
porturile I/O la adresele 0x03f0 – 0x3f5 si 0x3f7. [17]
5. Interfeţele Ethernet
Interfaţa Ethernet virtuală a VMware este AMD PCnet bazată pe chipul AMD 79C970A sau pentru
sistemele client pe 64 de biţi Intel Pro/100MT Server Adapter. Se pot adăuga până la 10 interfeţe Ethernet care
sunt de mai multe tipuri:
• Reţea host-only, numai pe sistemul gazdă şi este folosită la comunicarea între client şi sistemul pe care
rulează VMware.
• Reţea bridged, care funcţionează asemănător modului în care VMware funcţionează pentru UCP,
multiplexând interfaţa Ethernet pentru ca sistemul client să comunice cu gazda.
• Reţea NAT (Network Address Translation), este o reţea de tip host-only care foloseşte NAT pentru a
comunica cu reţelele exterioare prin intermediul reţelei gazdă.
Interfaţa virtuală Ethernet este un dispozitiv PCI, deci întreruperile şi porturile I/O sunt setate la
pornire.[13]

6. Porturile seriale
VMware are 4 porturi seriale virtuale 16550A UART ce sunt configurate ca în tabelul de mai jos:
Nume DOS Nume Linux IRQ Porturi I/O
COM1 /dev/ttyS0 4 0x3f8-0x3ff
COM2 /dev/ttyS1 3 0x2f8-0x2ff
COM3 /dev/ttyS2 4 0x3e8-0x3ef
COM4 /dev/ttyS3 3 0x2e8-0x3ef
Deoarece porturile COM 2 si COM 4, respectiv COM 1 şi COM3 împart acelaşi număr IRQ pot apărea
erori la folosirea simultană a lor.[13]
7. Porturile paralele
Porturile paralele sunt folosite pentru a transmite un număr mai mare de biţi simultan decât porturile
seriale. VMware suportă două porturi PC paralele în moduri unidirecţionale şi bidirecţionale:
Nume DOS Nume Linux IRQ Porturi I/O
LPT1 /dev/lp0, /dev/parport0 7 0x3be
LPT2 /dev/lp1, /dev/parport1 5 0x37f
Similar cu portul serial, datele de ieşire pentru porturile paralel pot fi direcţionate către un fişier în locul
unui dispozitiv real.[13]
8. Interfaţa USB
VMware emulează controllerul UHCI (Universal Host Controller Interface) pentru USB 1.1 sau EHCI
(Extended Host Controller Interface) pentru USB 2.0, suportând o gamă variată de dispozitive: imprimante,
scannere, cititoare de carduri, mouse, tastaturi etc.[16]
9. Adaptor grafic
VMware are un adaptor grafic VGA16 şi unul SVGA care permite folosirea extensiilor VGA şi poate afişa
la aceleaşi rezoluţii ca şi sistemul gazdă. Totusi, pentru folosirea acestor opţiuni este nevoie să se instaleze un
software auxiliar numit VMware Tools pentru sistemul client care permite comunicarea directă cu sistemul video
de pe calculatorul gazdă.[16]
10. Mouse, tastatură şi tablete grafice
Toate aceste dispozitive sunt virtualizate astfel:
• Tastatura: 104 Key Windows 95/98 enhanced
• Mouse: PS/2 Mouse

• Tablete grafice: Generic Serial Tablets
11. Plăci de sunet
VMware emulează dispozitivul Creative Technology SoundBlaster 16, IRQ 5, porturi I/O 0x220 – 0x22f,
canal DMA 16 biti. Deoarece placa de sunet foloseşte IRQ 5, pot apărea conflicte dacă unul din porturile paralele
doreşte să folosească simultan această întrerupere.
12. BIOS-ul (Basic Input Output System)
VMware foloseşte versiunea de BIOS PhoenixBIOS 4.0 Release 6 VESA şi emulează totodată RTC-ul (Real-
Time Clock) sistemului gazdă.
VMware ESX Server
VMware ESX Server este un produs oferit de VMware Inc. pentru virtualizarea sistemelor de tip server.
Principala diferenţă între VMware ESX Server şi Workstation este aceea că cel dintâi funcţionează direct pe
hardwareul serverului şi nu necesită un sistem de operare gazdă. Avantajul este acela de a rula mai multe
sisteme de operare simultan folosind direct resursele hardware ale maşinii. ESX server este destinat în special
utilizatorilor din mediul de afaceri şi nu utilizatorilor individuali, pretându-se cel mai bine sistemelor de tip
multiprocesor performante.
ESX Server încorporează un manager de resurse şi o consolă de servicii care asigură controlul pornirii
precum şi alte servicii. Designul arhitecturii ESX Server implementează mecanisme care permit resurselor
hardware să fie alocate mai multor sarcini de lucru simultan în medii complet izolate.
Elementele cheie ale designului sistemului sunt:
• Stratul de virtualizare VMware care asigură un mediu hardware ideal şi virtualizarea resurselor hardware
• Managerul de resurse care permite partiţionarea şi garantarea UPC, memoriei, lăţimii de bandă a reţelei
şi a discurilor pentru fiecare maşină virtuală.
• Interfaţa componentelor hardware care include driverele dispozitivelor, ce permite livrarea unor servicii
hardware specifice, ascunzând totodată diferenţele hardware pentru alte componente ale sistemului.
Virtualizarea ESX Server presupune ca şi în cazul Workstation definirea pentru fiecare maşină virtuală a
unui procesor virtual, a unei memorii s.a.m.d. Pentru fiecare staţie virtuală se pot de asemenea defini mai multe
interfeţe Ethernet (maxim 4) fiecare cu adresa IP si MAC proprii ce pot fi conectate la un switch virtual care la
rândul lui poate fi conectat printr-o legatură de tip bridge la reţeaua fizică a sistemului gazdă. Virtualizarea ESX
server poate fi uşor interpretată din figura de mai jos (fiecărei maşini virtuale îi corespunde o UPC, o memorie şi
un disc propriu, în realitate toate împărţind aceleaşi resurse)[15]:

Masina virtuala 1
UPC Memorie Disc NIC NIC
UPC1 Mem 1 Disc
1
UPC 1
NIC1a NIC 1b
UPC n
Resurse fizice
Mem 1
………………………………
Mem n
Configuraţia maşinii virtuale [3]
Procesele şi fişierele Consolei de Servicii (Service Console)
Consola de servicii este o componentă cheie a VMware Server şi oferă control API (Application
Programming Interface) care permite maşinilor virtuale şi resurselor alocate să fie manageriate. Administratorul
poate de asemenea să acceseze aceste controale direct prin pagini Web de pe serverul web ce rulează în
interiorul consolei de servicii. Consola de servicii este practic un sistem de operare cu nucleul vmkernel. [4]
Diagrama consolei de servicii [14]
NIC1b… NIC
Retea Virtuala
Pe lângă serverul web, în consola de servicii mai rulează următoarele procese:
• Server daemon (vmserverd): execută acţiuni în consola de servicii din parte VMware Remote Console
(controlul consolei de pe un alt sistem) bazate pe Interfaţa de management Web.
• Authentification daemon (vmauthd): autentifică utilizatorii interfeţei de management şi consolele
folosind un sistem bazat pe un nume de utilizator şi parolă.
• Server SNMP (Simple Network Management Protocol) (ucd-snmpd): implementează structurile de date
SNMP.
Cerinţe minime pentru staţia pe care se instalează VMware ESX Server.
Disc 1
Disc 2
NIC 1a
NIC na
Masina virtuala n
UPC Memorie Disc NIC NIC
UPC n Mem n Disc n NICna NIC nb

VMware Converter
Un alt produs al companiei VMware Inc. care are la bază virtualizarea este VMware Converter. Acesta
are mai multe întrebuinţări:
• Converteşte maşini fizice în maşini virtuale pentru a putea fi folosite cu alte produse VMware (Ex:
converteşte un disc real în timp ce acesta rulează într-o imagine virtuală ce poate fi acesată din VMware)
• Converteşte maşini virtuale pentru a putea fi folosite cu alte produse VMware.
• Schimbă locul maşinilor virtuale pe diferite platforme VMware.
• Importă sau exportă aplicaţii virtuale din sistemul local sau le downloadeaza de pe un URL.
• Reajustează rapid mărimile discurilor şi tipurile partiţiilor pentru a maximiza utilizarea resurselor de
stocare.
Spre exemplu, VMware Converter este foarte util atunci când se doreşte migrarea de la un sistem de
operare la altul, dar să se păstreze vechiul sistem de operare. [17]
ÎmbunătăŃirea performanŃelor VMware
VMware este o aplicaţie consumatoare de resurse însă performanţele pot fi îmbunătăţite renunţănd la
unele elemente în favoarea altora. Cel mai mare plus de performanţă se obţine pornind de la sistemul gazdă.
• Procesorul maşinii gazdă trebuie să execute cât mai puţine instrucţiuni aşadar este recomandat să se
ruleze o singură maşină virtuală la un moment dat.
• Deşi producătorul recomandă un minim de 512 MB de memorie RAM, ideal sunt 2 GB pentru a obţine o
performanţă cât mai bună. Trebuie să fie destulă memorie astfel încât să se ruleze atât sistemul gazdă
cât şi clientul simultan. Pentru gazdele Linux cu nucleu din seria 2.2.x maximul de memorie suportat este
1GB aşadar este nevoie fie de un upgrade al kernelului la o versiune 2.4.x fie o recompilare a nucleului
folosind opţiunea CONFIG_2GB astfel încât să se aloce 2GB pentru nucleu şi 2 GB pentru utilizator (în
mod normal se alocă 1GB pentru kernel şi 3 GB pentru utilizator).
• Trebuie evitate situaţiile în care nu există suficient spaţiu liber pe hard diskul staţiei gazdă. Performanţa
poate scădea considerabil atunci când VMware Workstation (sau alt produs VMware) vrea să execute
operaţii cu discurile virtuale (de crestere, snapshot, redo etc.). O altă idee pentru îmbunătăţire este de a
împărţi maşinile virtuale pe hard diskuri diferite sau folosirea unei interfeţe RAID şi defragmentarea
periodică a discurilor virtuale.
• Se recomandă ca în cazul în care sistemul posedă mai multe plăci de interfaţă cu reţeaua (NIC) să se
activeze doar cea care este folosită la un moment dat şi nu toate simultan.
• Dezactivarea CD-ROM-ului în VMware pentru fiecare maşină virtuală îmbunătăţeste de asemenea
performanţa.
• Din punct de vedere grafic performanţa se poate îmbunătăţi dacă se dezactivează efectele vizuale
(Windows) sau se rulează VMware în full-screen.
• Instalarea VMware Tools aduce de asemenea îmbunătăţiri.

x86 virtualization
x86 virtualization este o metodă prin care un x86 de bază cu un sistem de operare poate să ruleze sub
un alt calculator numit gazdă, ce are un x86, cu sistem de operare, cu puţine sau fară nicio modificare asupra
primului sistem de operare.
Termenul general de x86 se referă la un set de instrucţiuni pentru cele mai de succes arhitecturi de
procesoare din istoria calculatoarelor personale. Aceste instrucţiuni sunt folosite in procesoarele de la INTEL,
AMD, VIA si derivă de la primele generaţii de procesoare, începând cu procesorul pe 16 biţi Intel 8086 ce a
apărut la sfârşitul anilor 86. De atunci setul de instrucţiuni a fost frecvent extins.
Arhitectura procesorului x86 nu a corespuns la început cerinţelor de virtualizare Popek si Goldberg.
Astfel a fost greu să se implementeze o maşina virtuală pe un processor x86.
Cerinţele Popek şi Goldberg sunt un set de condiţii suficiente pentru ca un calculator să suporte eficient
un sistem virtualizat. Acestea au fost introduce de Gerald J. Popek si Robert P. Goldberg intr-un articol din anul
1974 sub numele de : “Formal Requisements for Virtualizable Third Generation Arhitectures”. Chiar dacă
cerinţele sunt derivate luând forme simplificate, ele tot reprezintă o cale convenabilă pentru a determina dacă
arhitectura unui calculator suportă eficient virtualizarea.
Pentru a obţine aceste cerinţe de virtualizare Popek şi Goldberg au introdus o clasificare a instrucţiunilor
in 3 grupe diferite:
• Instrucţiuni privilegiate: acestea sunt accesibile daca procesorul este în user mode şi nu sunt accesibile
dacă procesorul este in sistem mode.
• Instrucţiuni pentru controlul sensibilităţii: sunt instrucţiuni ce încearcă sa schimbe configuraţia
resurselor în sistem.
• Instrucţiuni pentru funcţionarea sensibilitaţii: acele instrucţiuni ale căror funcţionări depinde de
configurarea resurselor.
Rezultatul principal al analizei Popek şi Goldberg poate fi exprimat sub forma a 2 teoreme [5]:
Teorema 1 - Pentru cea de-a treia generaţie de calculatoare un VMM (“Virtual Machine Monitor”) poate fi
construită daca setul 2 de instrucţiuni este un subset al primului. Intuitiv enunţul teoremei exprimă faptul că
instrucţiunile care ar putea afecta funcţionarea corectă a VMM (instrucţiuni pentru controlul sensibilităţii)
trebuie blocate şi controlul trebuie trecut VMM-lui. Acest lucru garantează controlul calitativ al resurselor. Nicio
altă instrucţiune privilegiată nu trebuie executată.
Teorema 2 - O a treia generaţie de calculatoare este recursiv virtualizată dacă:
1. Este virtualizată
2. Poate fi construit un VMM fără a depinde de timp
Intel si AMD au dezvoltat independent exdinderea virtualizarii arhitecturii x86. Ele nu sunt direct
compatibile intre ele, dar satisfac in mare aceleaşi funcţii. Oricum vor permite unei masini virtuale ce are mai
multe sisteme de operare pe acelaşi calculator gazdă în acelaşi timp, sa ruleze un sistem de operare
nemodificat, secundar, fără a suporta penalitaţi importante de emulare a perforamntelor.

Virtuozzo
Spre deosebire de soluţiile prezentate până acum , acest program foloseşte tehnologia de virtualizare
host based , neincluzând astfel modelul de abstractizare al componentelor hardware. Acest program se
evidenţiază printr-un nivel ridicat de performanţă in utilizare şi dispune de utilitare de administrare complete .
Virtuozzo ofera un set complet de utilitare de monitorizare, acestea oferind informaţii utile
administratorilor care gestionează mediul virtual. Creează mai multe recipiente izolate , (cunoscute ca medii
virtuale sau virtual environments (VE)) sau Servere Virtuale Private (VPS) pe un singur server fizic . Aceasta
metoda permite punerea in comun a resurselor hardware , a sistemelor de management şi câteodată a
licenţelor software in diferite sarcinii . [11]
Fiecare VPS se comporta exact ca un server obişnuit în ceea ce priveşte utilizatorii si aplicaţiile, poate fi
resetat independent si are acces individual de nivel root, utilizatori si adrese IP individuale, memorie, fişiere de
configurare, procese, aplicaţii, librării de sistem si fişiere de configurare proprii. Uşor de întreţinut si cu un design
eficient, Virtuozzo este o soluţie eficientă de virtualizare atât pentru sisteme Linux/UNIX, cât si Microsoft
Windows.
Caracteristici
Platformele Linux sunt considerate cele mai potrivite pentru Virtuozzo, având documentaţia completă
pentru cele mai cunoscute distribuţii . Avantajele principale ale Virtuozzo sunt : partiţionarea inteligentă , prin
care un server se împarte in multe recipiente cu funcţionalităţi complete a unui server obişnuit; izolarea
completă , recipientele sunt in siguranţă şi au izolare din punct de vedere al performanţei , funcţionalităţii şi a
eroriilor;alocarea de resurse dinamice – unitatea de control si procesare (CPU) , memoria , reţeaua , discurile şi
intrările/ieşirile pot fi schimbate fară resetarea serverului; Magement in masă – un set de utilitare şi şabloane
pentru automatizare,multi-recipiente şi multi-administrarea de server.
Modelul de virtualizare SO a Virtuozzo este ideal pentru cea mai buna performanţă, management şi
eficienţă. La bază sta un sistem de operare gazdă standard care poate fi atât Windows cât şi Linux. Următorul
este un strat de virtualizare cu un sistem al gestiunii de fişiere şi un strat abstractizat al kernelului care asigură
izolarea şi securizarea resurselor dintre diferite recipiente. Stratul de virtualizare face din fiecare recipient să
pară un server de sine stătator.
Soluţia de virtualizare a SO Virtuozzo are cea mai mare eficientă şi scalabilitate, astfel încât e considerată
cea mai bună soluţie pentru organizaţiile din domeniul infrastructurii IT şi eficientizarea utilizării resurselor. Setul
complet de utilitare de management şi arhitectura unică fac din Virtuozzo cea mai soluţia perfectă pentru
intreţinerea usoară, monitorizare şi administrarea resurselor serverului virtual.
Diagrama de mai jos reprezintă un model tipic al structurii de sistem Virtuozzo [11]

Figura 1 . Virtuozzo Virtualizare SO [11]
Recipientul insăşi găzduieşte aplicaţia, se comportă ca şi cum ar fi un server de sine-stătător. Fiecare
recipient are superutilizatorul său (root sau Administrator), un set de useri sau grupuri, adrese IP, procese,
fişiere, aplicaţii, fişiere, aplicaţii, librării de system şi fişiere de configurare. Recipientul este accesibil prin retea.
Datorită stivei de reţea virtuală, recipientul are tabele proprii de rutare si seturi de reguli ale firewall-ului
(iptables).
OpenVZ
OpenVZ este o soluţie de virtualizare şi automatizare completă a serverului. Această creează mai multe
Server Virtuale Private (VPS) izolate intre ele pe un singur server fizic pentru a eficientiza la maxim resursele
oferite. Fiecare VPS realizează şi execută asemănător unui server de sine stătător pentru utilizatorii săi şi
aplicaţii, putând fi resetat independent şi având access la root-ul său, utilizatori, adrese IP, memorie, fişiere,
aplicaţii, librarii de sistem şi fişiere de configurare. Designul eficient a OpenVZ îl recomandă ca fiind alegerea
potrivită pentru serverele de producţie cu aplicaţii live şi date in timp real. [1]
Posibilităţiile de bază a OpenVZ sunt :
• Partiţionarea dinamică în timp real – un server fizic se poate partiţiona în zeci de VPS-uri, fiecare cu
funcţionalităţi diferite şi cu atribuţii de server dedicat.
• Managementul resurselor – atribuie şi controlează resursele parametrilor VPS şi realoca resursele în
timp real.

• Management în masă – Administrează o reţea de server fizice şi servere virtuale private printr-o metodă
unitară.
Din punct de vedere al aplicaţiilor şi a utilizatorilor de VPS, fiecare server virtual este un sistem
independent. Această independenţă este oferită de un strat de virtualizare in kernelul sistemului de operare a
gazdei. Interesant este faptul că o mică parte a resurselor CPU sunt ocupate cu virtualizarea (aproape de 2 %).
Principalele caracteristici a stratului virtual implementat în OpenVZ sunt următoarele:
• VPS arată ca un sistem de operare Linux normal. Are scripturile de început standard, software care
rulează în VPS fără OpenVZ – modificări specifice sau adaptări .
• Un utilizator poate schimba orice fişier de configurare şi poate instala software adiţional.
• Servere virtuale private sunt izolate complet între ele (fişiere de sistem, procese, Comunicate Inter
Procese (IPC) ).
• Procese ce aparţin unui VPS sunt programate pentru execuţie pentru toate resursele CPU valabile. În
consecinţă, VPS-urile nu sunt legate doar la un singur CPU şi pot utiliza toată puterea CPU.
ComparaŃie
Spre deosebire de alte soluţii de virtualizare, Virtuozzo nu alocă decât sub 3% din resursele serverului
pentru taskurile de virtualizare si administrare, permiţând instalarea unui număr foarte mare de servere virtuale
pe un singur server fizic. Tehnologia avansată de virtualizare permite ca orice VPS sa poată fi mutat uşor de pe
un server fizic pe altul.
Z-machine
Prima schiţă a unei maşini Z a apărut pe o masă de cafea în 1979 în Pittsburg. Este un calculator virtual a
cărui programe sunt jocuri de aventură, perfect adaptat acestei misiuni, întrucât reuşeşte să implementeze
jocuri complexe pentru perioada sa într-un mod compact. Se poate spune că erau totuşi un pic prea mari pentru
memoria disponibilă calculatoarelor personale din acele zile, dar maşina Z pare să fi fost prima care să utilizeze
memoria virtuală într-un microcalculator. Mult mai impresionant decât acest amănunt este posibilitatea de a
salva si a reporni programul exact în locul unde a fost lăsat într-un mod eficient.
Principiul cardinal al designului acestei maşini esta de a putea fii 100% portabil pe orice tip de calculator.
Această portabilitate este facută posibilă din dorinţa de a face constrânge programele la un minim de memorie
precum şi cerinţele cât mai mici hardware (spre exemplu alocarea dinamică este imposibilă).
Jocurile create de Infocom continuă să fie vândute şi jucate sub programe interpretor create ori de
Infocom ori de surse independente. În jur de 130 de jocuri-poveşti compilate sub Zilch (care este compilatorul
firmei Infocom) mai supravieţuiesc şi din 1993 mult mai multe jocuri-poveşti au fost create ţinând cont de
sistemul de referinţă Inform. Există 8 versiuni ale maşinii Z iar primul byte din orice “joc-poveste” (adică orice
program al maşinii Z) dă numarul versiunii sub care trebuie interpretat codul.

O privire asupra structurii maşinii Z
Structura Maşinii Z [6]
Maşinile Z sunt precum spuneam un calculator virtual. “Z” vine de la “Zork”, jocul de aventură text
pentru care a fost originar conceput. Ca orice calculator îşi ţine informaţiile (majoritatea lor) într-o matrice de
variabile numerotate de la 0 în sus care constituie memoria sistemului. Un număr de 240 de locuri de memorie
sunt separate de restul sistemului pentru un acces rapid si uşor, iar la aceste adrese de memorie sunt denumite
variabile globale (pentru că sunt disponibile oricărei părţi ale programului in execuţie, la orice moment de timp).
Cele mai importante două informaţii neţinute în memorie sunt contorul de program (PC) şi stiva. Maşina
Z rulează programul în mod continuu luând instrucţiunea de la poziţia ţinută în PC, executând respectiva
instrucţiune după care incrementează în mod automat PC-ul. Setul de instrucţiuni al maşinii Z (plaja tuturor
acţiunilor posibile şi cum sunt ele codate ca şi numere în memorie) ocupă cea mai mare parte a unui program
menit să ruleze pe o astfel de maşină.
Programele sunt divizate în rutine : maşina Z executând mereu rutina care este indicată de contorul de
program. Totuşi, unele instrucţiuni cer efectuarea unor salturi sau execuţia unor rutine noi după care trebuie să
se întoarcă în locul unde a fost lăsată rutina precedentă. Pentru informaţiile privitoare la locul unde să se
întoarcă maşina se foloseşte de stivă. Stiva este un al doilea banc de memorie, total separat de memoria
principală, de unde sunt luate sau în care se adaugă anumite informaţii. Stiva este de tip FIFO (first in first out).
În afară de a reţine locurile de întoarcere în rutină în stivă se mai reţin variabilele locale (folosite doar de
anumite rutine din program), cât şi pentru a ţine minte pentru o perioadă scurtă de timp rezultatele parţiale ale
unor calcule.

Astfel, în timp ce majoritatea procesoarelor fizice au un număr de variabile uşor de accesat ăn afara
memoriei principale (zone numite “registre”) şi o stivă in interiorul memoriei principale, maşina Z are exact
invers : variabilele globale sunt ţinute in interiorul memoriei şi stiva in afara acesteia. Accesul la resursele
hardware ale calculatorului pe care rulează maşina Z nu se pot face decât apelând instrucţiuni specifice. Spre
exemplu, instrucţiunile read şi read_char permit folosirea tastaturii; print şi draw_picture permit folosirea
ecranului. Imaginea afişată pe ecran nu este reţinută nicăieri in memorie. În mod simetric, resursele hardware
pot intrerupe rutina curentă a maşinii. Acest lucru se întâmplă doar dacă programul a cerut în prealabil acest
lucru, cum ar fi de exemplu dacă se cere o întrerupere pentru treizeci de secunde pentru a da timp jucătorului
timp de gâmdire pentru a scrie un răspuns. După expirarea timpului programul va genera o întrerupere pentru a
analiza răspunsul utilizatorului.
Această simplă arhitectură este intercalată cu mai multe structuri speciale pe care maşina Z le menţine
inăuntrul memoriei. Sunt in jur de douăsprezece astfel de structuri dar cele mai importante sunt :
• Header-ul, care se află mereu la adresa cu numărul de ordine cel mai mic, unde se ţin informaţii privind
programul şi o mapare a restului memoriei
• Dicţionarul, care conţine o listă de cuvinte pe care programul se aşteaptă să le îi fie date de la tastatură
• Arborele obiectelor, care reprezintă un aranjament de bucăţi de memorie
Maşina Z este folosită cel mai adesea pentru jocuri de aventură tip text, astfel că dicţionarul ţine minte
nume de obiecte sau verbe pe care utilizatorul trebuie să le introducă, în timp ce obiectele ce compun arborele
sunt locuri si artefacte care compun jocul. Orice obiect din arbore poate avea un părinte, un frate sau un copil.
Obiectele sunt colecţii de variabile în principiu, variabile care se împart in două categorii: atribute şi
proprietaţi.
Atributele sunt simple fanioane, în sensul că pot fii doar active sau inactive, ele neavând nicio valoare
numerică. Proprietaţile conţin numere, care la rândul lor pot reprezenta bucăţi de text sau alte tipuri de
informaţii. Spre exemplu, o proprietate a obiectului „cutie poştală” conţine informaţia despre denumirea
obiectului. Un atribut al acestui obiect este faptul că este un container, în sensul că el conţine la rândul lui alte
obiecte copil. Acest atribut este dezactivat în cazul obiectului „notiţă”.
Programele pentru maşini Z sunt stocate local pe disc, sau arhivate pe Internet, în ceea ce se numesc
„fişiere poveste”(story files). Aceste fişiere conţin doar un cadru al memoriei principale. Procesorul începe să
ruleze un astfel de fişsier începând cu o stivă goală şi o valoare a contorului de program în concordanţă cu
informaţiile conţinute in headerul fişierului. Trebuie menţionat că în prealabil fişierele poveste trebuie să fie
corelate cu structurile de memorie care conţin dicţionarul au arborele de obiecte.
Primul byte din orice fişier poveste, cel conţinut la adresa 0, conţine întotdeauna numărul versiunii
maşinii Z ce trebuie folosite. Designul acestei maşini a fost unul revoluţionar pe o perioadă de o decadă. Astfel
pe măsură ce numărul versiunii creştea, setul de instrucţiuni creştea şi tabelele de memorie erau reformatate
pentru a face loc jocurilor mai complicate şi mai mari din punct de vedere al necesităţii memoriei. Toate jocurile
făcute de Infocom pot fi jucate folosind versiuni variind între 3 (majoritatea) si 6. Toate jocurile compilate de
Inform în anii ’90 folosesc preponderent versiunile 5 şi 8.

Maparea memoriei
1.1 Regiunile memoriei
Memoria maşinii Z este impărţită in trei regiuni : “dinamică”, “statică” şi “mare”(high) . Memoria
dinamică începe la adresa byte-ului $00000 şi merge până la byte-ul înainte de adresa byte-ului conţinut în
cuvântul aflat la adresa $0e din header. Memoria dinamică trebuie să conţină cel puţin 64 de bytes. Memoria
statică porneşte imediat după ultima adresa a memoriei dinamice. Lungimea acesteia nu este specificată
nicăieri, dar trebuie să se termine la ultimul byte al fişierului poveste sau la adresa $0ffff (oricare este mai mică).
Memoria high incepe de la fanionul de memorie high (adresa stocată în cuvântul aflat la adresa $04 din header)
şi se continuă până la sfârşitul fişierului poveste. Începutul stivei de memorie high se poate suprapune peste
sfârşitul stivei de memorie statică însă nu şi cu memoria dinamică.
Memoria dinamică poate fi scrisă sau citită (fie direct folosind instrucţiunile loadb , loadw şi storeb şi
storew, sau în mod indirect folosind opcode-urile insert_obj sau remove_obj)
Prin tradiţie, primii 64 de bytes sunt cunoscuţi drept header. Majoritatea jocurilor nu le este permis să
modifice biţii aflaţi in header. Este în schimb permis jocurilor să altereze orice tabele stocate în memoria
dinamică, cu condiţia să lase tabelele respectând regulile versiunii de maşină Z pe care ruleză.
Memoria statică poate fi citită folosind opcode-urile loadb si loadw. În schimb este ilegal pentru un joc
de a încerca să scrie in memoria statică.
În afară de posibila suprapunere cu memoria statică, memoria high nu poate fi accesată direct de un
program joc. În schimb aceasta conţine rutine, care pot fi rulate, sau şiruri de caractere care pot fi printate
folosind comanda print_paddr.
Lungimea maximă permisă a unui fişier poveste depinde de versiune, cum urmează.
V1-3 V4-5 V6 V7 V8
128 256 512 320 512
1.2 Adrese
Sunt trei tipuri de adrese în maşina Z, toate putând fi stocate într-un număr de doi bytes : adrese de
bytes, adrese de cuvinte şi adrese împachetate.
O adresă de byte specifică adresa respectivului byte în memorie ţi poate varia între 0 şi ultimul byte
alocat memoriei statice.
O adresă de cuvânt specifică o adresă pară în ultimii 128K ai memoriei (dând astfel adresa divizată cu
doi). Adresele de cuvânt sunt folosite doar in tabela de abreviere.
O adresa împachetată specifică locul unde o rutină sau un şir începe în memoria high. Fiind dată o
adresă împachetată P, formula corespunzătoare pentru a obţine adresa byte-ului B este :
2P Versiunile 1, 2 and 3
4P Versiunile 4 and 5
4P + 8R_O Versiunile 6 şi 7, pentru adresarea rutinelor
4P + 8S_O Versiunile 6 and 7, pentru print_paddr

$2a )
8P Versiunea 8
R_O şi S_O sunt offsetul pentru rutine şi şiruri (specificate în header la cuvintele de la adresele $28 şi
Inform niciodată nu compilează suprapunerea dintre memoria statică şi cea high (îşi plasează toate
tabelele în memoria dinamică). Totuşi, jocurile Infocom grupează tabelele chiar deasupra fanionului de memorie
high, chiar înainte de a începe rutinele.Unele jocuri intercaleză datele statice între rutine astfel încât memoria
statică se suprapune peste cod, şi alte jocuri pot conţine rutine plasate sub fanionul de memorie high. (Ideea
originală din spatele fanionului de memorie high a fost că tot ceea ce se află sub el ar trebui stocată în RAM-ul
interpretorului, în timp ce se află deasupra ar putea fii ţinut în memoria virtuală). De asemenea ar trebui
menţionat faptul că memoria dinamică si cea statică nu ar trebui să depăşească 64K. Aceasta era cea mai mare
limitare a maşinii Z, cu toate că această limită nu a fost niciodată atinsă.[3]
Bibliografie
Cărţi:
1. Andrew S. Tanenbaum Operating Sistems. Design and Implementation
2. Andrew S. Tanenbaum Modern Operating Systems 2 nd Edition
3. Abraham Silberschatz, Operating System Concepts
4. M. Waite, F. Lafore – Structuri de date şi algoritmi în Java, ed. Teora, 2001
5. Robert Tolksdorf - Languages for the Java VM, Berlin 2005
6. Irina Atanasiu, B. Constantinescu, O. A. Drăgoi, Florentina Irina Popovici – Limbajul Java, ed.
Agora,1998
7. The Book Of VMware - The Complete Guide To VMware Workstation (2002) , Brian Ward
Site-uri de internet:
8. http://ro.wikipedia.org/wiki/Java_(limbaj_de_programare)
9. http://en.wikipedia.org/wiki/Java_bytecode
10. http://java.sun.com/docs/books/tutorial/
11. http://en.wikipedia.org/wiki/Virtuozzo
12. http://www.parallels.com/en/products/virtuozzo/
13. VMware Workstation 6.0 User Manual
14. VMware Converter User Manual
15. VMware ESX Server Administration Guide
16. VMware ESX Server Installation Guide