Scrigroup - Documente si articole

Username / Parola inexistente      

Home Documente Upload Resurse Alte limbi doc  

CATEGORII DOCUMENTE





AccessAdobe photoshopAlgoritmiAutocadBaze de dateCC sharp
CalculatoareCorel drawDot netExcelFox proFrontpageHardware
HtmlInternetJavaLinuxMatlabMs dosPascal
PhpPower pointRetele calculatoareSqlTutorialsWebdesignWindows
WordXml


Sisteme de operare UNIX de timp-real

linux

+ Font mai mare | - Font mai mic







DOCUMENTE SIMILARE

Trimite pe Messenger
Configuring Linux VPNs
Sistemul de operare UNIX
Codes, scripts and configurations
Terminarea proceselor - UNIX
Telnet, TFTP, and xinetd
Structura sistemului UNIX
Crearea proceselor - UNIX
Semnale - UNIX
Scenarii pentru regasirea unui buffer - UNIX
Adrese si configurare de retea - Configurarea unui modem in RedHat

Sisteme de operare UNIX de timp-real

                UNIX-ul este un sistem de operare deschis (engl.: open system). in comparatie cu cele care l-au precedat, utilizatorii au acces la toate facilitatile pe care le detine sistemul, poate fi extins cu usurinta prin adaugareať unor dispozitive periferice sau controlere de retea si este independent hardware. Resursele sistemului UNIX pot fi utilizate prin intermediul unui set de proceduri numite apeluri de sistem (engl,: system calls) care sunt disponibile pentru programele scrise in C sau alte limbaje care accepta apeluri de proceduri conventionale.



Caracteristicile sistemelor de operare UNIX de timp-real

            Sistemele de operare UNIX au fost initial proiectate pentru prelucrari multitasking si cu divizarea timpului (engl. time sharing). Cerintele de timp-real sunt in general incompatibile cu implementarea eficienta a unui sistem de operare multitasking si multiutilizator. Sistemele UNIX conventionale nu ofera un timp de raspuns corespunzator multor aplicatii de timp-real si nici posibilitatea unui schimb de date adecvat.

            Mecanismul de planificare la sistemelor UNIX conventionale aloca cuante de timp (engl.: time-slice) proceselor pentru ca acestea sa evolueze in mod echitabil. Prioritatile proceselor se recalculeaza periodic, astfel incat acestea sa partajeze timpul unitatii centrale in mod cat mai corect.

            Performantele temporale ale unui proces de timp-real pot fi predeterminate daca sunt cunoscute performantele algoritmilor din codul sursa, tipul codului generat de calculator si viteza de calcul. Aceasta implica planificarea proceselor astfel incat accesul la unitatea la unitatea centrala sa fie complet predeterminat Algoritmii de planificare utilizati sunt: round-robin, F1FO si cu prioritati fixe. Pentru procese de timp-real, acestia trebuie sa fie preemptivi, adica un proces mai putin prioritar este intrerupt din executie imediat ce un proces mai prioritar este activat (a intrat in starea 'gata de executie').

1.        Prioritatile proceselor

            In aplicatiile de timp-real trebuie ca utilizatorii sa aiba controlul direct al prioritatilor proceselor. Acestea trebuie sa fie fixe, eventual modificabile de catre utilizator, dar in nici un caz sa nu poata fi modificate automat de catre sistemul de operare. Politicile de planificare ar trebui sa fie schimbate in functie de necesitatile aplicatiei. Procesele cu prioritati egale ar trebui sa fie executate prin alocarea circulara si nu prin divizarea timpului.

2.        Preemptiunea

            Sistemele de operare UNIX conventionale sunt deficitare, din punctul de vedere al aplicatiilor de timp-real, prin modul de tratare a intreruperilor. Daca un proces cu prioritate mica efectueaza un apel de sistem, sistemul de operare va continua executia acestuia chiar daca intre timp a fost activat un proces cu prioritate mai mare. Deoarece executiile unor apeiuri de sistem pot dura cateva secunde, aceste intarzieri datorate executiilor functiilor sistemului nu sunt acceptabile pentru multe aplicatii de timp-real.

3.       Operatii de l/E asincrone

Sistemele de operare UNIX conventionale nu ofera posibilitatea unei operatii I/E asincrone si nici facilitatea conectarii directe a unor dispozitive I/E ale utilizatorului. De asemenea sunt deficitare cu privire la posibilitatea de rezervare pentru citiri si scrieri.

4.        Procese rezidente in memoria principala

Exista posibilitatea retinerii unui proces in memorie, crescand astfel viteza de raspuns a sistemului la producerea unor evenimente, dar nu exista si posibilitatea de rezervare a unor dispozitive.

5.  Alocarea fixa a memoriei interne pentru fisiere

            Sistemul de fisiere este creat prin alocarea dinamica a spatiului necesar. Nu exista insa nici o garantie ca spatiul necesar va fi disponibil atunci cand va trebui. Nu se garanteaza ca un fisier creat pe disc are alocat un spatiu continuu. Aceasta duce la scaderea performantelor (temporale) de lucru cu fisierele.

            In scopul portabilitatii programelor aplicatiilor s-au conceput o serie de standarde.

Cele mai cunoscute organizatii pentru standardizare in acest domeniu sunt:

ˇ            the American National Standard organlzation (ANSI);

ˇ            the International Standard Organlzation (ISO);

ˇ            the Institute of Electronic and Electrical Engineers (IEEE).

            Cel mai cunoscut standard pentru sistemele UNIX este the Portable Operation interface for computer environmentS (POSIX). Acesta a fost conceput de catre Comitetul 1003 pentru standarde al IEEE

In exemplul precedent procesui parinte va scrie:

            inceputul testului fork

            Sfarsitul testului fork

            Procesul copil va scrie numai: Sfarsitul testului fork

            Prin urmare, procesul copil va repeta identic activitatea procesului parinte din momentul apelului functiei fork.

            Pentru ca procesul copil sa efectueze operatii diferite de cele ale procesului parinte trebuie sa se utilizeze faptul eh fork intoarce o valoare diferita procesului parinte fata de cea a procesului copil. Aceasta este posibil deoarece nucleul creeaza un nou proces in timp ce procesul parinte este inca activ. Valorile diferite intoarse de functia fork pot fi utilizate pentru a discerne intre cele doua procese in care se vor continua executiile.

            Fork furnizeaza procesului parinte identificatorul procesului copil, daca acesta a fost creat. Identificatorul este o valoare intreaga pozitiva (mai mare decat 1). Daca nu poate crea procesul copil din cauza lipsei unor resurse fork transmite procesului parinte valoarea -l (uzual in limbajul C, -l indica o eroare).




         Functia fork  furnizeaza procesului copil valoarea 0.

Exemplul 2:

#   include  <stdio.h>

main  ()

Programul   de   mai   sus   va scrie

Proces parinte - secventa 1

Proces parinte - secventa 2

Proces copil     - secventa 3

Exemplul dat poate imple­menta structuri de tipul celei prezen­tate in figura 6.15 unde liniile paralele specifica executia concu­renta a secventelor 2 si 3.

            Secventa    1

Secventa    2

Secventa    3

Diagrama unui program cu secvent concurente

Exemplul 3:

#include <stdio.h>

main ()

           Spre deosebire de programele din exemplele 1 si 2, cel din exemplul 3 va semnala daca nu poate crea procesul copil.

           Un proces poate cunoaste propriul sau identificator prin apelarea functie getpid sau cel al parintelui cu funtia getppid. Daca un proces are mai multi copii, el poate cunoaste identificatorul fiecaruia dintre ei. Un proces copil mai nou poate cunoaste identificatorul unui proces copil mai vechi. Un proces copil  mai mare nu poate cunoaste identificatorul unui proces copil mai mic, cu exceptia cazului in care ii este transmis de catre proces.

Initializarea proceselor cu functia exec

            Exista 6 functii din familia exec. Scopul lor este de suprascriere a unor segmente de text si date ale unui proces cu alte fisiere executabile. intr-un program normal fara un apel exec( ) explicit, segmentul de date se modifica numai de catre procesul insusi. Daca exista un apel exec() intr-un program, in mod normal, segmentul de date va fi modificat de catre procesul care il detine, dupa ce segmentul de date a fost initializat in urma apelarii.

            Una dintre cele mai simple functii din familia exec este execlp( ), care lanseaza in executie programe ce pot sa nu fie situate in radacina. in exemplul urmator se poate vedea modul ei de utilizare.

Exemplul 4:

#include  <stdio.h.>

main   ()

           

            Argumentele functiei execlp ( ) sunt citite din segmentul de date, iar segmentul de stiva primeste adresa de revenire ( de la o posibila intoarcere ) din execlp ( ). Daca era o oricare alta functie (diferita de exec ( ) ) se revenea la adresa depusa in stiva.

           

            In figura de mai jos se pot vedea continuturile segmentelor procesului inainte de executia apelului execlp, iar in figura urmatoare, dupa executia lui. S-a presupus ca programul executabil obtinut din exemplul prezentat se numeste 'apelant', iar programul care se doreste sa fie lansat poarta denumirea de 'numeprog' si se afla intr-un fisier (diferit de radacina) 'nume fisier '. Din aceste doua figuri se poate observa ca dupa executia apelului execlp, segmentul de text contine numai prima instructiune puts din programul apelant la care se adauga instructiunile din programul 'numeprog'. Segmentul de date de asemenea este inlocuit cu date din 'numeprog'.








Politica de confidentialitate

DISTRIBUIE DOCUMENTUL

Comentarii


Vizualizari: 1154
Importanta: rank

Comenteaza documentul:

Te rugam sa te autentifici sau sa iti faci cont pentru a putea comenta

Creaza cont nou

Termeni si conditii de utilizare | Contact
© SCRIGROUP 2019 . All rights reserved

Distribuie URL

Adauga cod HTML in site