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

Maşini virtuale

Masterand IISC: Andreea HONCIUC

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 VM WARE ........................................................................................................... 12 DISPOZITIVELE VM WARE ....................................................................................................... 13 VM WARE ESX SERVER ........................................................................................................... 16 VM WARE CONVERTER ............................................................................................................ 18 ÎMBUNĂTĂłIREA PERFORMAN łELOR VM WARE ..................................................................... 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:

Structura Java Runtime Environment [5]

Arhitectura ma şinii virtuale Java 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

rulează 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.

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

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:

Ethernet SCSI SVGA

IDE Sunet Altele

PCI-to-ISA bridge Magistrala PCI

MMU

UPC

Memorie

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]:

………………………………

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]

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.

Resurse fizice NIC1b… NIC

Retea Virtuala

UP

C 1

UP

C n

Mem

1

Mem

n

Disc 1

Disc 2

NIC

na

NIC

1a

Masina virtuala 1

UPC Memorie Disc NIC NIC

UPC1 Mem 1 Disc 1

NIC1a NIC 1b

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

8P Versiunea 8

R_O şi S_O sunt offsetul pentru rutine şi şiruri (specificate în header la cuvintele de la adresele $28 şi

$2a )

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 2nd

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