Licenta Time Scheduling POPESCU MARIAN ALEXANDRU MIHAI

Universitatea Titu Maiorescu
Facultatea de Informatic
LUCRARE DE LICEN
Coordonator tiinific
Lect. Univ. Dr. Radu Boriga
Absolvent:
Popescu Marian Alexandru Mihai
Bucureti, 2013
CUPRINS
Introducere..................................................................................................................................3
Capitolul 1: Algoritmi Greedy....................................................................................................4
1.1 Noiuni introductive.......................................................................4
1.2 Clase de metode de optimizare....................................................6
1.3 Algoritmi iterativi i convergen................................................6
1.4 Clasificarea metodelor de optimizare.........................................7
Capitolul 2: Tehnica Divide et Impera........................................................................................8
Algoritmi de programare dinamic.................................................................11
2.1 Cautare binara...............................................................................11
2.2 Branch & Bound............................................................................14
2.3 Arborii binari de cutare tip data..............................................16
2.4 Arborele optim..............................................................................16
Capitolul 3: ALGORITMI DE PROGRAMARE DINAMICE................................................18
3.1 Trei Principii fundamentale ale Programrii Dinamice...........18
3.2 Programarea dinamic comparat cu tehnica GREEDY..........20
Capitolul 4: Planificarea proceselor..........................................................................................21
4.1 Planificarea proceselor................................................................21
4.2 Criteriile planificrii......................................................................21
4.3 Problemele planificatorului.........................................................21
4.4 Strategiile planificatorului..........................................................21
4.5 First Come First Served Scheduling.........................................22
4.6 Round Robin Scheduling..............................................................25
4.7 Round Robin..................................................................................26
4.8 Alegerea cuantei...........................................................................27
4.9 Priority scheduling.......................................................................27
4.10 Gruparea prioritilor................................................................31
Capitolul 5: Problema optimizare.............................................................................................35
5.1 Modelul problemei de planificare..............................................35
5.2 Descrierea matematic a problemei.........................................38
5.3 Metode clasice de rezolvare.......................................................40
Aplicatie....................................................................................................................................47
Concluzii...................................................................................................................................53
Bibliografie...............................................................................................................................54
Introducere
Un proces reprezinta un set de activitati din program, care nu se pot suprapune (se
executa secvential). Un proces este determinat de o secventa de instructiuni (o procedura) din
programul care se executa. Termenul de proces este folosit pentru a desemna obiectul
activitatii procesorului, in timpul executiei unui program.
Algoritmii de planificare a executiei proceselor sunt impartiti, in principiu, in doua
mari clase: nonpreemptivi si preemptivi.
Algoritmii nonpreemptivi sunt proiectati ca, atunci cand un proces intra in executie, sa
fie rulat pana cand a fost epuizat timpul sau de executie. Algoritmii preemptivi se conduc
dupa notiunea de prioritate; procesul cu prioritatea cea mai mare trebuie sa fie cel care
foloseste procesorul
Programarea dinamic este o metod de elaborare a algoritmilor care se aplic n
general problemelor pentru care se cere determinarea unui optim n urma adoptrii unor
decizii.
Nu exist un criteriu pe baza cruia s identificm cu siguran o problema pentru
rezolvarea creia trebuie s utilizm metoda programrii dinamice, dar putem formula doua
proprieti care sugereaz o soluie prin programare dinamica.
n aceast lucrare ncerc s prezint cteva din metodele generale de elaborare a
algoritmilor de programare a activitatilor.
Capitolul 1: Algoritmi Greedy
1.1 Noiuni introductive

Algoritmii greedy (greedy = lacom) sunt in general simpli si sunt folositi la probleme de
optimizare, cum ar fi: sa se gaseasca cea mai buna ordine de executare a unor lucrari pe
calculator, sa se gaseasca cel mai scurt drum intr-un graf etc. In cele mai multe situatii de
acest fel avem:
multime de candidati (lucrari de executat, varfuri ale grafului etc)

functie care verifica daca o anumita multime de candidati constituie o solutie posibila, nu
neaparat optima, a problemei
functie care verifica daca o multime de candidati este fezabila, adica daca este posibil sa
completam aceasta multime astfel incat sa obtinem o solutie posibila, nu neaparat
optima, a problemei
functie de selectie care indica la orice moment care este cel mai promitator
dintre candidatii inca nefolositi
functie obiectiv care da valoarea unei solutii (timpul necesar executarii tuturor lucrarilor
intr-o anumita ordine, lungimea drumului pe care l-am gasit etc); aceasta este functia pe
care urmarim sa o optimizam (minimizam/maximizam)
Pentru a rezolva problema noastra de optimizare, cautam o solutie posibila care sa

optimizeze valoarea functiei obiectiv. Un algoritm greedy construieste solutia pas cu pas.
Initial, multimea candidatilor selectati este vida. La fiecare pas, incercam sa adaugam acestei
multimi cel mai promitator candidat, conform functiei de selectie. Daca, dupa o astfel de
adaugare, multimea de candidati selectati nu mai este fezabila, eliminam ultimul candidat
adaugat; acesta nu va mai fi niciodata considerat. Daca, dupa adaugare, multimea de candidati
selectati este fezabila, ultimul candidat adaugat va ramane de acum incolo in ea. De fiecare
data cand largim multimea candidatilor selectati, verificam daca aceasta multime nu constituie
o solutie posibila a problemei noastre. Daca algoritmul greedy functioneaza corect, prima
solutie gasita va fi totodata o solutie optima a problemei. Solutia optima nu este in mod
necesar unica: se poate ca functia obiectiv sa aiba aceeasi valoare optima pentru mai multe
solutii posibile.
function greedy(C)
{C este multimea candidatilor}
S {S este multimea in care construim solutia}
while not solutie(S) and C do
x un element din C care maximizeaza/minimizeaza select(x)
C C \ {x}
if fezabil(S {x}) then S S {x}
if solutie(S) then return S
else return nu exista solutie
Este de inteles acum de ce un astfel de algoritm se numeste lacom (am putea sa-i
spunem si nechibzuit). La fiecare pas, procedura alege cel mai bun candidat la momentul
respectiv, fara sa-i pese de viitor si fara sa se razgandeasca. Daca un candidat este inclus in
solutie, el ramane acolo; daca un candidat este exclus din solutie, el nu va mai fi niciodata
reconsiderat. Asemenea unui intreprinzator rudimentar care urmareste castigul imediat in
dauna celui de perspectiva, un algoritm greedy actioneaza simplist. Totusi, ca si in afaceri, o
astfel de metoda poate da rezultate foarte bune tocmai datorita simplitatii ei. Functia select
este de obicei derivata din functia obiectiv; uneori aceste doua functii sunt chiar identice. Un
exemplu simplu de algoritm greedy este algoritmul folosit pentru rezolvarea urmatoarei
probleme. Sa presupunem ca dorim sa dam restul unui client, folosind un numar cat mai mic
de monezi. In acest caz, elementele problemei sunt:
candidatii: multimea initiala de monezi de 1, 5, si 25 unitati, in care

presupunem ca din fiecare tip de moneda avem o cantitate nelimitata
o solutie posibila: valoarea totala a unei astfel de multimi de monezi selectate

trebuie sa fie exact valoarea pe care trebuie sa o dam ca rest
o multime fezabila: valoarea totala a unei astfel de multimi de monezi selectate

nu este mai mare decat valoarea pe care trebuie sa o dam ca rest
functia de selectie: se alege cea mai mare moneda din multimea de candidati
ramasa
functia obiectiv: numarul de monezi folosite in solutie; se doreste minimizarea

acestui numar
Se poate demonstra ca algoritmul greedy va gasi in acest caz mereu solutia optima
(restul cu un numar minim de monezi). Pe de alta parte, presupunand ca exista si monezi de
12 unitati sau ca unele din tipurile de monezi lipsesc din multimea initiala de candidati, se pot
gasi contraexemple pentru care algoritmul nu gaseste
solutia optima, sau nu gaseste nici o solutie cu toate ca exista solutie.
Evident, solutia optima se poate gasi incercand toate combinarile posibile de monezi.
Acest mod de lucru necesita insa foarte mult timp. Un algoritm greedy nu duce deci
intotdeauna la solutia optima, sau la o solutie. Este doar un principiu general, urmand ca
pentru fiecare caz in parte sa determinam daca obtinem sau nu solutia optima.
1.2 Clase de metode de optimizare

Dimensiunea problemelor
O msur a complexitii problemei de programare este dimensiunea acesteia
exprimat prin numrul de necunoscute i de restricii. Dimensiunea problemelor care pot fi
rezolvate a crescut o dat cu dezvoltarea teoriei i a tehnicilor de calcul.
Se pot distinge acum trei categorii de probleme: de dimensiune redus (cu cel mult 5
variabile sau restricii), de dimensiune medie (ntre 5 i 100 de variabile sau restricii) i de
dimensiuni mari (cu peste 100 de variabile i restricii). Aceast clasificare reflect nu numai
diferene de dimensiuni, dar i de abordare. Astfel problemele de dimensiuni mici pot fi
rezolvate de mn sau cu un calculator de buzunar. Problemele de dimensiuni medii pot fi
rezolvate pe un calculator, folosind programe matematice generale. Problemele de dimensiuni
mari necesit programe sofisticate care exploateaz caracteristicile particulare ale problemei
i de obicei se ruleaz pe calculatoare de mare capacitate.
Teoria iniial a optimizrii s-a concentrat asupra obinerii rezultatelor teoretice
ignornd aspectele de calcul ale metodelor propuse. Abordrile recente se axeaz pe
exploatarea caracteristicilor calculatoarelor, obinnd soluia prin metode iterative.
1.3 Algoritmi iterativi i convergen

Cea mai important caracteristic a calculatoarelor este capacitatea lor de a efectua
operaii repetitive ntr-un mod eficient i din aceast cauz majoritatea algoritmilor de
rezolvare a problemelor de optimizare sunt iterativi. n cutarea unei soluii se alege un vector
iniial x0 i algoritmul determin un vector x1 care conduce la o valoare mai bun a funciei
obiectiv; procesul se repet obinndu-se un ir de vectori x0, x1, , xk, , fiecare
mbuntind valoarea funciei obiectiv, fa de precedentul. Acest ir converge ctre x*,
soluia problemei. n problemele de programare liniar soluia se obine dup un numr finit
de pai. n probleme de programare neliniar irul nu atinge niciodat soluia, dar converge
ctre ea. Practic, algoritmul se oprete cnd s-a obinut un punct suficient de aproape de
soluie.
Teoria algoritmilor iterativi poate fi mparit n trei pri. Prima parte se ocup cu
crearea de algoritmi. A doua parte, numit i analiza convergenei globale, analizeaz
convergena unui algoritm ctre soluia optim atunci cnd se iniializeaz cu un punct
deprtat de soluia optim. Cea de-a treia component se numete analiza convergenei locale
6
i studiaz rata de convergen a irului ctre soluia optim. Este esenial cnd se recomand
un algoritm s se menioneze i o estimare a timpului necesar pentru obinerea soluiei. [3]
1.4 Clasificarea metodelor de optimizare

n funcie de numrul i tipul variabilelor, de numrul de restricii, sau de tipul funciei
ce trebuie optimizat, modelele i metodele de optimizare se mpart n mai multe categorii.
Tabelul de mai jos ilustreaz principalele categorii de metode de optimizare:
Metoda
Programare liniar
Determinarea
drumului
Funcie obiectiv
Liniar
minim Liniar
(Dijkstra)
Minimum spanning tree
Algoritmul Ford/Fulkerson
PERT i gestionea resurselor
Branch and Bound
Algoritmul Balas (cu valiabile binare)
Algoritmi genetici
Algoritmul Hooke i Jeeves
Metoda Lagrange
Metode GRG
Programare quadric
Programare liniar secvenial
Programare quadric secvenial
Restricii
Liniare
Liniare
Liniar
Liniar
Liniare
Liniare
Liniar
Liniare
Neliniar
Neliniar
Neliniar
Quadric
Neliniar
Neliniar
Fr restricii
Egaliti neliniare
Neliniare
Liniare
Liniare
Capitolul 2: Tehnica Divide et Impera
Divide et impera este o tehnic de elaborare a algoritmilor care const n:

Descompunerea cazului ce trebuie rezolvat intr-un numr de subcazuri mai mici ale aceleiai
probleme.
Rezolvarea succesiv i independenta a fiecruia din aceste subcazuri.
Recompunerea subsoluiilor astfel obinute pentru a gsi soluia cazului iniial.
7
S presupunem c avem un algoritm A cu timp ptratic. Fie c o constant, astfel

nct timpul pentru a rezolva un caz de mrime n este tA(n) = cn2. S presupunem c este
posibil s rezolvam un astfel de caz prin descompunerea n trei subcazuri, fiecare de
mrime .n/2.. Fie d o constant, astfel nct timpul necesar pentru descompunere i
recompunere este t(n) = dn. Folosind vechiul algoritm i ideea de descompunere-recompunere
a subcazurilor, obtinem un nou algoritm B, pentru care:
t B 3t A ( n / 2 ) t (n) 3c((n 1) / 2) 2 dn 3 / 4cn 2 (3 / 2 d )n 3 / 4c
Termenul 3/4cn2 domin pe ceilali cnd n este suficient de mare, ceea ce nseamn
ca algoritmul B este n esen cu 25% mai rapid dect algoritmul A. Nu am reuit ns s
schimbm ordinul timpului, care rmne ptratic. Putem s continum n mod recursiv acest
procedeu, mprind subcazurile n subsubcazuri etc. Pentru subcazurile care nu sunt mai mari
dect un anumit prag n0, vom folosi tot algoritmul A. Obinem astfel algoritmul C, cu timpul.
Iat o descriere general a metodei divide et impera:

function divimp(x)
{returneaz o soluie pentru cazul x}
if x este suficient de mic then return adhoc(x)
{descompune x n subcazurile x1, x2, , xk}
for i . 1 to k do yi . divimp(xi)
{recompune y1, y2, , yk n scopul obinerii soluiei y pentru x}
return y
unde adhoc este subalgoritmul de baz folosit pentru rezolvarea micilor subcazuri ale
problemei n cauza (in exemplul nostru, acest subalgoritm este A).
Un algoritm divide et impera trebuie s evite descompunerea recursiv a
subcazurilor suficient de mici, deoarece, pentru acestea, este mai eficienta aplicarea directa
a subalgoritmului de baza. Ce nseamn ns suficient de mic?
In exemplul precedent, cu toate ca valoarea lui n0 nu influenteaz ordinul timpului,
este influenat ns constanta multiplicativa a lui n ln 3 , ceea ce poate avea un rol considerabil
n eficienta algoritmului. Pentru un algoritm divide et impera oarecare, chiar dac ordinul
timpului nu poate fi mbuntit, se dorete optimizarea acestui prag n sensul obinerii unui
algoritm ct mai eficient. Nu exist o metod teoretic general pentru aceasta, pragul optim
depinznd nu numai de algoritmul n cauz, dar i de particularitatea implementrii.
Considernd o implementare dat, pragul optim poate fi determinat empiric, prin msurarea
timpului de execuie pentru diferite valori ale lui n0 i cazuri de mrimi diferite.
8
n general, se recomand o metod hibrid care const n:

i)
determinarea teoretic a formei ecuaiilor recurente;
ii) gsirea empiric a valorilor constantelor folosite de aceste ecuaii, n funcie
de implementare.
Revenind la exemplul nostru, pragul optim poate fi gsit rezolvnd ecuaia:
t A (n) 3t A (n / 2) t ( n)
Empiric, gsim n0 67, adic valoarea pentru care nu mai are important dac
aplicm algoritmul A n mod direct, sau dac continuam descompunerea. Cu alte cuvinte,
atta timp ct subcazurile sunt mai mari dect n0, este bine s continum descompunerea.
Dac continum ns descompunerea pentru subcazurile mai mici dect n0, eficienta
algoritmului scade.
Observm ca metoda divide et impera este prin definiie recursiv. Uneori este
posibil s eliminam recursivitatea printr-un ciclu iterativ. Implementata pe o maina
convenionala, versiunea iterativa poate fi ceva mai rapida (n limitele unei constante
multiplicative). Un alt avantaj al versiunii iterative ar fi faptul c economisete spaiul de
memorie. Versiunea recursiv folosete o stiva necesar memorrii apelurilor recursive.
Pentru un caz de mrime n, numrul apelurilor recursive este de multe ori n .(log n), uneori
chiar n .(n).
Fie G=<V,M> un graf orientat, unde V este mulimea vrfurilor i M este mulimea
muchiilor. Fiecrei muchii i se asociaz o lungime negativ. Dorim s calculm lungimea
celui mai scurt drum ntre fiecare pereche de vrfuri.
Vom presupune c vrfurile sunt numerotate de la 1 la n, i c matricea L d
lungimea fiecrei muchii: L[i,i]=0, L[i,j]0 pentru ij, L[i,j]=+ dac muchia (i,j) nu exist.
Principiul optimalitii este valabil: dac cel mai scurt drum de la i la j trece prin
vrful k, atunci poriunea de drum de la i la k ct i cea de la k la j, trebuie s fie, de asemenea
optime.
Construim o matrice D care s conin lungimea celui mai scurt drum ntre fiecare
pereche de vrfuri. Algoritmul de programare dinamic iniializeaz pe D cu L, apoi
efectueaz n iteraii. Dup iteraia k, D va conine lungimile celor mai scurte drumuri care
folosesc ca vrfuri intermediare doar vrfurile din {1,2,,k}. Dup n iteraii, obine rezultatul
final. La iteraia k, algoritmul trebuie s verifice pentru fiecare pereche de vrfuri (i,j) dac
exist sau nu un drum, trecnd prin vrful k, care este mai bun dect actualul drum optim ce
trece doar prin vrfurile din {1,2,,k-1}. Fie Dk matricea D dup iteraia k.
Verificarea necesar este atunci:
Dk[i,j]=min(dk-1[i,j], Dk-1[i,k]+Dk-1[k,j])
unde am fcut uz de principiul optimalitii pentru a calcula lungimea celui mai scurt drum
via k. implicit, am considerat c un drum optim care trece prin k nu poate trece de dou ori
prin k.
Acest algoritm simplu este datorat lui Floyd (1962):
function Floyd(L[1..n, 1..n])
9
array D[1..n, 1..n]

DL
for k1 to n do
for i1 to n do
for j1 to n do
D[i,j] min (D[i,j], D[i,k]+D[k,j])
return D
De exemplu, dac avem:
0 5
50 0 15 5
D0 L
30 5 0
15 5 0
obtinem succesiv
De obicei dorim s aflm nu numai lungimea celui mai scurt drum, dar i traseul su. n
aceast situaie, vom construi o a doua matrice P, iniializat cu zero. Bucla cea mai interioar
a algoritmului devine
if D[i,k]+D[k,j]<D[i,j] then D[i,j]D[i,k]+D[k,j]
P[i,j]k
10
Cnd algoritmul se oprete, P[i,j] va conine vrful din ultima iteraie care a cauzat o
modificare n D[i,j]. Pentru a afla prin ce vrfuri trece cel mai scurt drum de la i la j,
consultm elementul P[i,j]. Dac P[i,j]=0, atunci cel mai scurt drum este chiar muchia (i,j).
Dac P[i,j]=k, atunci cel mai scurt drum de la i la j trece prin k i urmeaz s consultm
recursiv elementele P[i,k] i P[k,j] pentru a gsi i celelalte vrfuri intermediare.
Algoritmi de programare dinamic
2.1 Cautare binara

Cutarea binar este cea mai simpl aplicaie a metodei divide et impera, fiind
cunoscut nc nainte de apariia calculatoarelor. n esena, este algoritmul dup care se caut
un cuvnt intr-un dicionar, sau un nume n cartea de telefon.
Fie T[1 .. n] un tablou ordonat cresctor i x un element oarecare. Problema const
n a-l gsi pe x n T, iar dac nu se afl acolo n a gsi poziia unde poate fi inserat. Cutm
deci indicele i astfel nct 1 = i = n i T[i] = x < T[i+1], cu convenia T[0] = -8, T[n+1] = +8.
Cea mai evident metod este cutarea secvenial:
function sequential(T[1 .. n], x)

{caut secvenial pe x n tabloul T }
for i . 1 to n do
if T[i] > x then return i-1
return n
11
Algoritmul necesit un timp n (1+r), unde r este indicele returnat; aceasta

inseamn (1) pentru cazul cel mai favorabil i (n) pentru cazul cel mai nefavorabil. Dac
presupunem c elementele lui T sunt distincte, ca x este un element al lui T i c se afla cu
probabilitate egal n oricare poziie din T, atunci bucla for se execut n medie de (n2+3n2)/2n ori. Timpul este deci n (n) i pentru cazul mediu.
Pentru a mri viteza de cutare, metoda divide et impera sugereaz sa-l cutam pe
x fie n prima jumtate a lui T, fie n cea de-a doua. Comparndu-l pe x cu elementul din
mijlocul tabloului, putem decide n care dintre jumti s cutam.
Repetnd recursiv procedeul, obinem urmtorul algoritm de cutare binar:
function binsearch(T[1 .. n], x)
{cuta binar pe x n tabloul T}
if n = 0 or x < T[1] then return 0
return binrec(T[1 .. n], x)
function binrec(T[i .. j], x)
{cuta binar pe x n subtabloul T[i .. j]; aceasta procedura
este apelata doar cnd T[i] = x < T[ j+1] i i = j}
if i = j then return i
k (i+j+1) div 2
if x < T[k] then return binrec(T[i .. k-1], x)
else return binrec(T[k .. j], x)
Algoritmul binsearch necesit un timp n (log n), indiferent de poziia lui x n T
(demonstrai acest lucru, revznd. Procedura binrec execut doar un singur apel recursiv, n
funcie de rezultatul testului x < T[k]. Din aceast cauz, cutarea binar este, mai curnd,
un exemplu de simplificare, dect de aplicare a tehnicii divide et impera.
Iat i versiunea iterativ a acestui algoritm:

function iterbin1(T[1 .. n], x)
{cutare binara iterativa}
i 1; j n
while i < j do
{T[i] = x < T[ j+1]}
k (i+j+1) div 2
if x < T[k] then j k-1
else i k
return i
Acest algoritm de cutare binar pare ineficient n urmtoarea situaie: dac la un
anumit pas avem x = T[k], se continu totui cutarea. Urmtorul algoritm evita acest
inconvenient, oprindu-se imediat ce gsete elementul cutat.
function iterbin2(T[1 .. n], x)
{varianta a cutrii binare iterative}
i 1; j n
12
while i < j do
{T[i] = x < T[ j+1]}
k . (i+j) div 2
case x < T[k]: j k-1
x = T[k+1]: i k+1
otherwise: i, j k
return i
Timpul pentru iterbin1 este n (log n). Algoritmul iterbin2 necesit un timp care
depinde de poziia lui x n T, fiind n (1), (log n), (log n) pentru cazurile cel mai favorabil,
mediu i respectiv, cel mai nefavorabil.
Care din aceti doi algoritmi este oare mai eficient? Pentru cazul cel mai favorabil,
iterbin2 este, evident, mai bun. Pentru cazul cel mai nefavorabil, ordinul timpului este acelai,
numrul de executri ale buclei while este acelai, dar durata unei bucle while pentru iterbin2
este ceva mai mare; deci iterbin1 este preferabil, avnd constanta multiplicativ mai mic.
Pentru cazul mediu, compararea celor doi algoritmi este mai dificil: ordinul timpului este
acelai, o bucla while n iterbin1 dureaz n medie mai puin dect n iterbin2, n schimb
iterbin1 execut n medie mai multe bucle while dect iterbin2.
Un arbore binr n care fiecare frf conine o valoare numit cheie este un arbore de
cutare, dac cheia fiecrui vrf neterminal este mai mare sau egal cu cheia descendenilor
si stngi i mai mic sau egal cu cheia descendenilor si drepi. Dac cheile arborelui sunt
distincte, aceste inegaliti sunt, n mod evident, stricte.
Figura de mai sus este un exemplu de arbore de cutare *, coninnd cheile A, B, C,
,H. vrfurile pot conine i alte informaii n afar de chei, la care s avem acces prin
intermediul cheilor. Aceast structur de date este util, deoarece permitee o cutare eficient
a valorilor n arbore:
Cu o mulime dat de chei, se pot construi mai muli arbori de cutare(fig. de sus).
Pentru a cuta o cheie X n arborele de cutare, X va fi comparat la nceput cu cheia
rdcinei arborelui. Dac X este mai mic dect cheia rdcinii, atunci se continu cutarea n
subarborele stng. Dac X este egal cu cheia rdcinii, atunci cutarea se incheie cu succes.
Dac X este mai mare dect cheia rdcinii, atunci se cotinu cutarea n subarborele drept.
Se continu astfel recursiv accest proces.
13
Generm un arbore binar, conform urmtoarei metode recursive:

-rdcina este etichetat cu (1,n)
-dac un vrf este etichetat cu (i,j), i este mai mic dect j, atunci fiul su stng va fi etichetat
cu (i,r[i,j]-1) ;i fiul su drept cu(r[i,j]+1,j)
-vrfurile terminale sunt etichetate cu (i,i)
plecnd de la acest arbore, arborele de cutare optim se obine schimbnd
etichetele (i,j), i<j, n cr[i,j], iar etichetele (i,i) n ci.
2.2 Branch & Bound

Este strategia cea mai sofisticata de proiectare a algoritmilor. Ea a aparut datorita
existentei problemelor pentru care solutia de tip backtracking poate necesita un timp
astronomic de rulare a programului. In rezolvarea acestor probleme apare o asemenea penurie
de informatii incit modelul abstract asociat problemei - graful de cautare a solutiilor nu
poate fi precizat in avans, din etapa de analiza. Singura solutie care ramine este includerea
unui subalgoritm suplimentar ce permite construirea acestui graf pe parcurs, din aproape in
aproape. Aparitia acelui subalgoritm suplimentar da numele metodei: branch&bound.
Este posibila compararea algoritmului branch&bound cu un robot ce invata sa se
deplaseze singur si eficient printr-un labirint. Acel robot va fi obligat sa-si construiasca in
paralel cu cautarea iesirii o harta (un graf !) a labirintului pe care va aplica apoi , pas cu pas,
metode eficiente de obtinere a drumului cel mai scurt.
La strategia de cautare a solutiei in spatiul (graful) de cautare - backtracking, fiecare
pas urma automat unul dupa altul pe baza unei reguli incorporate, in timp ce la
strategia greedy alegerea pasului urmator era facuta pe baza celei mai bune alegeri. In cazul
acestei strategii branch&bound, pentru pasul urmator algoritmul nu mai este capabil sa faca
vreo alegere pentru ca este obligat mai intii sa-si determine singur nodurile vecine ce pot fi
vizitate. Numele metodei,branch=ramifica si bound=delimiteaza, provine de la cele doua
actiuni ce tin locul actiunii de alegere de la strategiaGreedy. Prima actiune este construirea sau
determinarea prin ramificare a drumurilor de continuare, iar a doua este eliminarea
continuarilor (ramurilor) ineficiente sau eronate. Prin eliminarea unor ramuri, portiuni intregi
ale spatiului de cautare a solutiei raminind astfel dintr-o data delimitate si izolate. Aceasta
strategie de delimitare din mers a anumitor regiuni ale spatiului de cautare a solutiilor este
14
cea care permite reducerea ordinului de marime a acestui spatiu. Solutia aceasta este eficienta
doar daca cistigul oferit prin reducerea spatiului de cautare (scazind efortul suplimentar depus
pentru determinarea si eliminarea din mers a continuarilor ineficiente) este substantial.
Solutiile de tip backtracking, avind la baza un schelet atit de general (algoritmul de
traversare a grafului de cautare a solutiilor) sint relativ simplu de adaptat in rezolvarea unor
probleme. Poate acesta este motivul care a condus pe unii programatori lipsiti de experienta la
convingerea falsa ca Orice este posibil de rezolvat prin backtracking.
La ora actuala, lista problemelor pentru care nu se cunosc decit solutii exponentiale, total
nerezonabile ca durata de executie a programului de solutionare, cuprinde citeva sute de
probleme, una mai celebra ca cealalta. Reamintim doar de banala (dar agasanta) Problema a
Orarului unei institutii de invatamint care nu admite o solutie backtracking datorita duratei
astronomice de asteptare a solutiei.
Datorita totalei lor ineficiente in executie, solutiile backtracking obtinute dupa o
analiza si o proiectare la prima mina (brute-force approach, in limba engleza) ajung sa fie
reanalizate din nou cu mai multa atentie. Se constata atunci ca modelul abstract asociat
problemei, fie este prea sarac in informatii pentru determinarea grafului de cautare a solutiilor,
fie conduce la un graf de cautare avind dimensiunea nerezonabila (exponentiala sau factoriala,
fata de dimensiunea n a vectorului de intrare). Singura solutie care ramine in aceasta situatie
la dispozitie este ca aceste solutii sa fie reproiectate prin metoda branch&bound.
Un exemplu usor de inteles de problema branch&bound il ofera Problema Generala
a Labirintului. Spre deosebire de Problema Labirintului prezentata anterior (care admitea o
solutie de tip backtracking), in varianta extinsa a acestei probleme, numarul directiilor
posibile de urmat la fiecare pas poate fi oricit de mare, iar obstacolele pot avea orice forma si
dimensiune. In acest caz, singura posibilitate este construirea din mers a spatiului de cautare
a solutiei. Astfel, pentru determinarea unui drum de iesire din labirint sau a drumului cel mai
scurt (daca este posibila determinarea acestuia in timp rezonabil!) este obligatorie adoptarea
strategiei branch&bound.
Desi aceasta strategie poate sa creasca uneori surprinzator de mult
eficienta algoritmilor de solutionare (din nerezonabili ca timp de executie ei pot ajunge
rezonabili, datorita reducerii dimensiunii exponentiale a spatiului de cautare a solutiei),
aplicarea ei este posibila doar printr-un efort suplimentar in etapa de analiza si in cea de
proiectare a algoritmului. Dezavantajul major al acestei metode consta deci in efortul major
depus in etapa de analiza a problemei (analiza care insa se va face o singura data si bine!) si
efortul suplimentar depus in etapa proiectarii algoritmului de solutionare.
Din experienta practica este cunoscut faptul ca, pentru a analiza o problema dificila un
analist poate avea nevoie de saptamini sau chiar luni de zile de analiza, in timp ce algoritmul
de solutionare proiectat va dura, ca timp de executie, doar citeva zeci de minute. Daca
programul obtinut nu este necesar a fi rulat decit o data, aceasta este prea putin pentru a se
amortiza costul mare al analizei si proiectarii sale. In acea situatie, solutia branch&bound
este nerentabila si, probabil ca ar fi mai ieftina strategia backtracking de solutionare, chiar si
cu riscul de a obtine o executie (singura de altfel) a programului cu durata de o saptamina
(ceea ce poate sa insemne totusi economie de timp).
2.3 Arborii binari de cutare tip data

ntr-o prim aproximare, arborele binar este un tip de dat similar tipului list.
Vrfurile sunt compuse din informaie cheie i legturi, iar arborele propriu-zis este complet
precizat prin adresa vrfului rdcin.
15
n cazul arborelui de cutare, nu mai este necesar o astfel de generalitate, deoarece

vom implementa direct operaiile specifice. n mare, aceste operaii sunt prite n:
-Cutri. Localizarea vrfului cu o anumit cheie, a succesorului sau predecesorului
su, precum i a vrfurilor cu cheile de valoare maxim, respectiv minim.
-Modificri. Arborele se modific prin tergerea sau inserarea unor vrfuri.
-Organizri. Arborele nu este construit prin inserarea elementelor, ci global prin
stabilirea unei legturi unice ntre vrfuri. Un caz particular al acestei operaii este
reorganizarea arborelui dupo perioad suficient de mare de utilizare.
2.4 Arborele optim

Vom rezolva problema obinerii arborelui optim n cel mai simplu caz posibil. Avnd
n vedere specificul diferit al operaiilor de organizare fa de celelalte operaii efectuate
asupra grafurilor, am considerat util s ncapsulm optimizarea ntr-o clas pe care o vom
numi structura pentru optimizarea arborilor.
Funcionalitatea ei const n:
-iniializarea unui tablou cu adresele vrfurilor n ordinea cresctoare a
probabilitilor cheilor.
-stabilirea de noi legturintre vrfuri, astfel nct arborele s fie optim.
Principala cauz pentru care a fost aleasaceast implementare este c sunt necesare
doar operaii de modificare a legturilor. Deplasarea unui vrf nseamn nu numai
deplasarea cheii, ci i a informaieiasociate.
Cutarea n arbore
Principala operaie efectuat prin intermediul arborilor binari de cutare este regsirea
informaiei asociate unei anumite chei. Actualizarea probabilitilor cheilor din arbore, dup
fiecare cutare, este cea mai delicat, deoarece impune stabilirea importanei evalurilor
existente n raport cu rezultatul cutrilor. De fapt este vorba de un proces de invare care
pornete de la cunotine deja existente n memorie. Problema este de a stabili gradul de
importan al cunotinelor existente n raport cu cele nou dobndite.
Modificarea arborelui
16
Modificarea structurii arborelui de cutare, prin inserare sau tergerea unor vrfuri
trebuie realizat astfel nct proprietatea de arbore de cutare s nu se altereze. Cele dou
operaii sunt diferite n privina complexitii. tergerea este mai dificil i mult mai diferit
de operaiile obinuite.
Complexitatea funciei de tergere este tipic pentru structurile de cutare. Aceste structuri
tind s devin att de compacte nct tergerea fiecrei chei necesit reparaii destul de
complicate. De aceea se prefer de cele mai multe ori o tergere lene, prin care vrful este
doar marcat ca fiind ters, tergerea fizic realizndu-se cu ocazia unor reorganizri periodice.
Capitolul 3: ALGORITMI DE PROGRAMARE

DINAMICE
3.1 Trei Principii fundamentale ale Programrii Dinamice
17
Programarea dinamic, ca i metoda divide et impera, rezolv problemele combinnd

soluiile problemelor. Dup cum am vzut, algoritmii divide et impera partiioneaz
problemele n subprobleme independente, rezolv problemele n mod recursiv, iar apoi
combin soluiile lor pentru a rezolva problema iniial. Dac subproblemele conin
subprobleme comune, n locul metodei divide et impera este mai avantajoas de aplicat tehnica
programrii dinamice.
Programarea dinamic este o metod de elaborare a algoritmilor care se aplic n
general problemelor pentru care se cere determinarea unui optim n urma adoptrii unor
decizii.
Nu exist un criteriu pe baza cruia s identificm cu siguran o problem pentru
rezolvarea creia trebuie s utilizm metoda programrii dinamice, dar putem formula dou
proprieti care sugereaz o soluie prin programare dinamic.
Problema dat poate fi descompus n subprobleme i soluia optim a problemei
depinde de soluiile optime ale subproblemelor sale.
Acest criteriu nu indic neaprat o soluie prin programare dinamic, ar putea fi i un indiciu
c se poate aplica metoda Greedy sau metoda Divide et Impera.
Subproblemele problemei date nu sunt independente, ci se suprapun.
Datorit faptului c subproblemele problemei date se suprapun, deducem c o abordare
prin metoda Divide et Impera ar fi dezastruoas din punctul de vedere al timpului de
execuie (datorit faptului c problemele se suprapun se ajunge la rezolvarea repetat a
aceleiai subprobleme). Prin urmare, vom rezolva subproblemele o singur, dat, reinnd
rezultatele ntr-o structur de date suplimentar (de obicei un tablou).
Rezolvarea unei probleme prin programare dinamic presupune urmtorii pai:
1.
Se
identific
subproblemele
problemei
date.
2. Se alege o structur de date suplimentar, capabil s rein soluiile subproblemelor.
3. Se caracterizeaz substructura optimal a problemei printr-o relaie de recuren.
4. Pentru a determina soluia optim, se rezolv relaia de recuren n mod bottom-up (se
rezolv
subproblemele
n
ordinea
cresctoare
a
dimensiunii
lor).
n cele ce urmeaz vom exemplifica pas cu pas modul de rezolvare a problemelor prin
metoda programrii dinamice.
Variabilele,sau funciile care descriu fiecare etap trebuie s fie n aa fel definite nct s
descrie complet un proces,deci pentru acest lucru va trebui s rspundem la dou ntrebri:
1) care este etapa iniial (caz n care avem de a face cu un proces decizional
descendent) sau careeste etapa final (caz n care avem de a face cu un proces
decizional ascendent)
2) care este regula dup care trecem dintr-o etap n alta ? De obicei aceast regul este
exprimat printr-o recuren.
Deoarece, avem de a face cu o problem care se rezolv n mai multe etape, nu ne
mai rmne dects vedem cum lum deciziile dintr-o etap n alta. Nu m refer aici la o
relaie de recuren de care amvorbit mai sus, ci la faptul c foarte probabil apare posibilitatea
ca la un anumit moment s putem alegedin mai multe decizii. De exemplu, problema
calculului numerelor lui Fibonaci se ncadreaz n categoria programrii dinamice deoarece:
este un proces n etape;
fiecrei etape k i corespunde calculul celui de al k-lea numr Fibonacci;
18
exist o singur decizie pentru a trece la o etap superioar;Determinarea unui drum ce

leag dou orae A i B i care trece printr-un numr minim de alteorae este tot
o problem de programare dinamic deoarece:
este un proces n etape,
fiecrei etape k i corespunde determinarea unui drum de lungime k ce pleac din
oraul A
dar exist mai multe decizii pentru trecerea la drumul de lungimea k + 1
Dac analizm natura problemelor care au fost rezolvate prin programare liniar sau
prin teoria grafurilor, constatm c procesul economic pe care doream s l optimizm se
desfura ntr-o singur faz (etap sau perioad). innd cont de faptul c exist numeroase
probleme de optimizare care modeleaz procese economice care se desfoar n mai multe
perioade i la fiecare perioad trebuie s stabilim soluia optim, viziunea static poate
constitui un neajuns. Este evident faptul c succesiunea de soluii nu se poate determina
innd seama numai de parametrii fiecrei perioade analizate n parte, i c este necesar s
identificm o succesiune de soluii care optimizeaz ntregul proces analizat. Problemele
economice care reclam o suit de decizii secveniale se caracterizeaz prin faptul c o decizie
care adoptat ntr-o anumit perioad are att un efect economic imediat, ct i unul de lung
durat, care influeneaz i asupra celorlalte etape.
Optimizarea proceselor secveniale se obine prin metodele unei teorii matematice
relativ recent constituite i care se numete programare dinamic. Creatorul acestei teorii este
Richard Bellman, iar lucrarea sa fundamental este Dynamic Programming aprut n anul
1957. Programarea dinamic are un cmp larg de aplicaie n cercetarea operaional
(organizarea produciei, gestiunea stocurilor, rennoirea echipamentelor), precum i n alte
domenii (navigaie cosmic, procese cu conexiune invers etc.). S presupunem un proces
secvenial a crui desfurare n timp depinde de o variabil care poate lua o mulime de
valori n fiecare etap. Ne putem decide pentru o valoare determinat a variabilei n fiecare
etap i din aceast cauz ea se numete variabil de decizie sau de control. O succesiune
oarecare de decizii constituie o politic i cea care ne intereseaz este politica optim, de pild
aceea care conduce la un cost total minim al procesului.
Deosebim dou tipuri principale de procese secveniale:
a) deterministe, cnd la fiecare faz procesul este controlat n ntregime de decizia pe care o
lum;
b) stohastice, atunci cnd evoluia procesului se desfoar sub dubla influen a deciziilor i a
hazardului.
Se numete politic optim acea succesiune de decizii care optimizeaz procesul n
ansamblu lui, fiind vorba de un proces determinist. n cazul unui proces stohastic, se folosete
n mod corespunztor noiunea de strategie optim.
Procesele dinamice pot fi continue sau discrete. Un exemplu de proces discret este
urmtorul: o ntreprindere trebuie s-i ntocmeasc planul de aprovizionare anual pentru un
anumit material; se consider 12 perioade (luni) i pentru fiecare perioad se stabilete
cantitatea de aprovizionat, astfel ca pe ntregul an s rezulte un cost total minim. Procesele
dinamice discrete pot avea orizontul limitat (n exemplu de mai sus 12 perioade) sau nelimitat.
3.2 Programarea dinamic comparat cu tehnica GREEDY

Att programarea dinamic, ct i tehnica greedy, pot fi folosite atunci cnd soluia
unei probleme este privit ca rezultatul unei secvene de decizii. Deoarece principiul
optimalitii poate fi exploatat de ambele metode, s-ar putea s fim tentai s elaborm o
soluie prin programare dinamic, acolo unde este suficient o metod greedy, atunci cnd
este necesar de fapt aplicarea programrii dinamice.
19
Vom considera o problem clasic de optimizare:

Un ho ptrunde ntr-un magazin i fur n obiecte,un obiect i avnd valoarea vi i
greutatea gi cum s-i optimizeze houl profitul, dac poate transporta cu un rucsac cel mult o
greutate G? deosebim dou cazuri. n primul dintre ele, pentru orice obiect i, se poate lua
orice fraciune din el, iar n al doilea caz un obiect poate fi ncrcat numai integral n rucsac.
Corespunztor acestor dou cazuri, obinem problema continu a rucsacului. Evident, houl va
selecta obiectele a. s maximizeze funcia obiectiv, unde x=(x1,x2,,xn) verific condiia.
Soluia problemei rucsacului poate fi privit ca rezultatul unei secvene de decizii. De
exemplu, houlve decide pentru nceput asupra valorii lui x1, apoi asupra lui x2 etc. printr-o
secven optim de decizii el va ncerca s maximizeze funcia obiectiv. Se observ c este
valabil principiul optimalitii. Ordinea deciziilor poate fi oricare alta.
Problema continu a rucsacului se poate rezolva prin metode greedy, selectnd la
fiecare pas, pe ct posibil n ntregime, obiectul pentru care vi/gi este maxim. Fr a restrnge
generalitatea, vom presupune c:
v1/g1 v2/g2 vn/gn
Putem demonstra c prin acest algoritm obinem soluia optim i c aceasta este de
forma x*=(1,,1,xk*,0,,0), k fiind un indice, 1 k n, astfel nct 0 xk 1. Algoritmul
greedy gsete secvena optim de decizii, lund la fiecare pas cte o decizie care este optim
local. Algoritmul este corect, deoarece nici o decizie din secven nu este eronat. Dac nu
considerm timpul necesar sortrii iniiale a obiectelor, timpul este n ordinul lui n.
Se observ imediat c tehnica greedy nu conduce n general la rezultatul dorit. De
exemplu, pentru g=(1,2,3), v=(6,10,12), G=5, algoritmul greedy furnizeaz soluia(1,1,0), n
timp ce soluia optim este (0,1,1). De aici vedem c tehnica greedy nu poate fi aplicat,
deoarece genereaz o decizie (x1=1) care este optim local, nu i global. Cu alte cuvinte, la
primul pas, nu avem suficient informaie local pentru a decide asupra valorii lui x1.
Problema se poate rezolva printr-un algoritm de programare dinamic, n aceast
situaie exploatndu-se complet principiul optimalitii.
Diferena esenial dintre tehnica greedy i programarea dinamic const n faptul c
metoda greedy genereaz o singur secven de decizii, exploatnd incomplet principiul
optimalitii. n programarea dinamic se genereaz mai multe subsecvene de decizii. O alt
caracteristic important a programrii dinamice este c se memoreaz subsecvenele optime,
evitndu-se astfel recalcularea lor.
Capitolul 4: Planificarea proceselor

4.1 Planificarea proceselor
componenta SO care determin care dintre procesele din sistem va
deveni activ: scheduler
20
schedulerul implementeaz un algoritm de planificare (scheduling

algorithm)
acest algoritm permite alegerea uneia din procesele aflate n starea
ready i marcarea acesteia ca fiind activ
dup alegere schedulerul realizeaz schimbarea contextului ntre
procesul care a fost activ i cel care este marcat s devin activ
4.2 Criteriile planificrii
fairness: fiecare proces s ocupe procesorul n mod cinstit

eficient: s menin utilizarea CPU ct mai aproape de 100%
timp de rspuns: minim
turnaround: minimizare timpului de ateptare
throughput: maximizarea numrului de joburi pe or
4.3 Problemele planificatorului

criteriile sunt contradictorii
de ex. pentru a minimiza timpul de rspuns ar trebui rulate ct mai
puine procese
o complicaie prezint faptul c fiecare proces este unic i impredictibil
unele procese petrec foarte mult timp ateptnd operaii IO, altele pot
rula ore ntregi fr ateptare
la activarea unui proces schedulerul nu poate s tie ct timp va rula
procesul nainte de a se bloca
4.4 Strategiile planificatorului

strategii de planificare preemtive: permit suspendarea temporar a
proceselor care ruleaz
la fiecare ntrerupere de ceas se ruleaz schedulerul care decide dac
procesul curent continu s ruleze sau nu, dac nu procesul va fi
suspendat i controlul dat altui proces
strategii de planificare non-preemptive: procesele ruleaz pn cnd i
termin execuia sau se vor bloca n ateptarea unei operaii IO
la apelul sistem de terminare sau cel blocant se ruleaz schedulerul
4.5 First Come First Served Scheduling

planificarea cea mai simpl
CPU va fi alocat proceselor n ordinea n care acestea se pornesc
21
procesele continu pn la terminare sau blocare, moment n care

urmtorul proces din list va fi planificat
se poate implementa foarte uor cu un FIFO
este o planificare non-preemptiv
import java.util.Vector;
public class FCFS
{
protected int[] arrivalTime;
protected int[] burstTime;
protected int[] job;
protected int[] jobIdle;
protected int numberOfProcess;
protected int[] waitingTime;
protected int[] finishedTime;
protected int averageWT,averageTTsum;
protected int jobs;
public FCFS (int[] aT,int[] bT,int[] job,int num)
{
arrivalTime = aT;
burstTime = bT;
this.job = job;
numberOfProcess = num;
waitingTime = new int[numberOfProcess];
finishedTime = new int[numberOfProcess];
jobs = 0;
}
public void FCFS()
{
int firstCome,tempArrivalTime,tempBurst;
for (int i = 0; i < (numberOfProcess - 1); i++)
{
for (int j = (i + 1); j < numberOfProcess; j++)
{
if (arrivalTime[j] < arrivalTime[i])
{
firstCome = job[j];
job[j] = job[i];
job[i] = firstCome;
tempArrivalTime = arrivalTime[j];
arrivalTime[j] = arrivalTime[i];
arrivalTime[i] = tempArrivalTime;
tempBurst = burstTime[j];
burstTime[j] = burstTime[i];
burstTime[i] = tempBurst;
}
}
}
System.out.println("\n==Displaying Table of Jobs Sorted According to Arrival Time==");
displaySorted();
22
System.out.println("======DISPLAYING GANTT CHART======");

solveWaitingTime();
solveAverageTime();
}
public void solveAverageTime()
{
//ATT
for(int i = 0;i<numberOfProcess;i++)
averageTTsum = averageTTsum+(finishedTime[i]-arrivalTime[i]);
//AWT
for(int j=0;j<numberOfProcess;j++)
averageWT = averageWT+(waitingTime[j] - arrivalTime[j]);
double aTT = (float)averageTTsum/numberOfProcess;

double aWT=(float)averageWT/numberOfProcess;
System.out.format("ATT: %.2f ",aTT);
System.out.println("");
System.out.format("AWT: %.2f ",aWT);
public void solveWaitingTime()

{ int ctr=0;
Vector<Integer> idleWT = new Vector<Integer>();
Vector<Boolean> idle = new Vector<Boolean>();
for(int z = 0; z < numberOfProcess; z++)
{
if(ctr > arrivalTime[z])
{idle.add(Boolean.TRUE);
for(int k = 0; k < burstTime[z]; k++)
{
ctr++;
}
jobs++;
}
else
{
while(ctr <= arrivalTime[z])
{
if(ctr == arrivalTime[z])
{
jobs++;
for(int j = arrivalTime[z]; j < (arrivalTime[z] + burstTime[z]); j++)
{
ctr++;
}
idle.add(Boolean.TRUE);
}
else
{
jobs++;
ctr++;
idle.add(Boolean.FALSE);
}
23
}
}
finishedTime[z] = ctr;
if(z==0)
idleWT.add(0);
else idleWT.add(ctr);
}
waitingTime[0] = 0;
for(int z = 1;z<numberOfProcess;z++)
{
waitingTime[z] = finishedTime[z] - burstTime[z];
}
System.out.println(""+idleWT.toString());
System.out.println(""+idle.toString());
System.out.println("Jobs: "+jobs);
int ctr2 = 0;
for(int y = 0; y < numberOfProcess; y++)
{
if(idle.elementAt(ctr2)==false)
{ if(ctr2==0)
{System.out.print("|I"+(waitingTime[y+1])+" |"); ctr2++;}
else {
System.out.print("|I "+(idleWT.elementAt(y)-waitingTime[y])+" |");
ctr2++;
}
}
System.out.print("|P"+job[y]+"("+burstTime[y]+")"+" |");
ctr2++;
}
for(int x = 0;x<numberOfProcess;x++)
{ if(idleWT.elementAt(x) == 0)
System.out.print(""+waitingTime[x]);
else System.out.print("
"+waitingTime[x]+ "
}
"+idleWT.elementAt(x));
}
public void displaySorted()
{
System.out.println("\n------------------------------------");
System.out.println("Process | Arrival Time | CPU Burst ");
for(int y = 0; y < numberOfProcess; y++)
{
System.out.println("P" + job[y] + "\t\t"
+ arrivalTime[y] +"\t
"
+ burstTime[y]);
}
24
System.out.println("------------------------------------\n");
}
}
4.6 Round Robin Scheduling

este unul din cele mai vechi i simpli algoritmi de planificare preemptive
fiecrei proces i se atribuie un interval de timp numit cuant, n care procesul se poate
executa
dac procesul nu-i termin execuia pn la expirarea cuantei de timp alocate, el va fi
ntrerupt iar CPU este alocat altui proces
dac procesul termin nainte de expirarea cuantei, se va planifica alt proces fr a se
atepta expirarea cuantei
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import junit.framework.TestCase;
class Robin {
private int i;
public Robin(int i) {
this.i = i;
}
public int call() {
return i;
}
}
class RoundRobin {
private Iterator<Robin> it;
private List<Robin> list;
public RoundRobin(List<Robin> list) {
this.list = list;
it = list.iterator();
}
public int next() {
if (!it.hasNext()) {
it = list.iterator();
}
Robin robin = it.next();
return robin.call();
}
}
public class RoundRobinTest extends TestCase {
List<Robin> items = new ArrayList<Robin>();
RoundRobin round;
25
public void testOne() {

items.add(new Robin(1));
round = new RoundRobin(items);
assertEquals(1, round.next());
}
public void testTwo() {
}
public void testThree() {
}
}
4.7 Round Robin

algoritmul este uor de implementat
planificatorul va menine o list a proceselor ce pot fi rulate (ready)
la expirarea cuantei, procesul activ va fi trecut la sfritul listei, iar
urmtorul proces din list va obine CPU
mean turnaround time
de ex. procesele A,B,C,D cu timpi de execuie 4,2,5,3,
mtt=10.75; iar pentru 6,1,4,2, mtt=8.25
4.8 Alegerea cuantei

o problem important n proiectare este alegerea cuantei
comutarea proceselor necesit un anumit interval de timp pentru
salvarea i ncrcarea registrelor, actualizarea tabelelor i listelor, etc.
de ex. cuant 20ms, timp de comutare 5ms t=> overhead de 20%
pentru a mri eficiena trebuie micorat overheadul, de ex. cuant
495ms, overhead 1%
dar cu cuanta mare timpul de rspuns crete: de ex. 10 utilizatori apas
Enter, ultimul va trebui s atepte 5s
26
stabilirea unei cuante mici va conduce la comutri multe scznd

eficiena CPU
stabilirea unei cuante mari cauzeaz un timp de rspuns mare pentru
utilizator
valorile uzuale pentru cuante sunt 1-100ms
informaii despre eficien
/proc/cpuinfo
/proc/stat
/proc/schedstat
4.9 Priority scheduling

n cazul Round Robin, procesele aveau aceeai prioritate
uneori ns va trebui s inem cont de prioritile n rezolvarea unor
probleme
fiecrei proces i se aloc o prioritate
la un moment dat va fi rulat procesul cel mai prioritar
pentru a previne rularea indefinit a proceselor prioritare schedulerul
poate descrete prioritatea procesului activ la fiecare ntrerupereAtribuirea
prioritilor
atribuire static
prioritate constant definit pentru un proces sau pentru utilizatorul care
pornete procesul
atribuire dinamic
modificare a prioritii n timpul rulrii
de ex. comanda nice permite unui utilizator s-i descreasc prioritatea
pentru a fi drgu cu ceilali
SO poate acorda prioritate mai mare unui proces care ateapt foarte
mult pentru IO i utilizeaz foarte puin CPU
#include<stdio.h>
struct proc
{
int id;
int pri;
int arrival;
int burst;
int rem;
int wait;
int start;
int finish;
int turnaround;
float ratio;
}process[10], temp;
int chkprocess(int);
int nextprocess();
void display();
27
int no,n;
main()
{
int i,a,j,k,time=0;
printf("\n \n ---PRIORITY SCHEDULING---\n \n ");
printf("\n \n Enter the number of processes: ");
scanf("%d", &n);
for(i = 1; i <= n; i++)
{
process[i].id = i;
printf("\n\nEnter the arrival time for process %d: ", i);
scanf("%d", &(process[i].arrival));
printf("\n Enter the burst time for process %d: ", i);
scanf("%d", &(process[i].burst));
printf("\n Enter the priority of the process %d:", i);
scanf("%d", & (process[i].pri));
process[i].rem = process[i].burst;
}
for(i = 1; i <= n; i++)
{
for(j = i + 1; j <= n; j++)
{
if(process[i].arrival > process[j].arrival)
{
temp = process[i];
process[i] = process[j];
process[j] = temp;
}
}
}
no = 0;
j = 1;
printf("\n \n Choices:");
printf("\n \n 1.Preemptive Priority Scheduling");
printf("\n \n 2.Non Preemptive Priority Scheduling");
printf("\n \n Enter your choice:");
scanf("%d", &a);
switch(a)
{
case 1:
{
while(chkprocess(n) == 1)
{
if(process[no + 1].arrival == time)
{
no++;
if(process[j].rem==0)
process[j].finish=time;
j = nextprocess();
}
28
if(process[j].rem != 0)
{
process[j].rem--;
for(i = 1; i <= no; i++)
{
if(i != j && process[i].rem !=
0)
process[i].wait++;
}
}
else
{
process[j].finish = time;
j=nextprocess();
time--;
k=j;
}
time++;
}
process[k].finish = time;
}
case 2:
{
process[1].start = process[1].arrival;
while(chkprocess(n) == 1)
{
if(process[no + 1].arrival == time)
no++;
if(process[j].rem != 0)
{
process[j].rem--;
for(i = 1; i <= no; i++)
{
if(i != j && process[i].rem !=
0)
process[i].wait++;
}
}
else
{
j = nextprocess();
time--;
process[j].start = time + 1;
}
time++;
}
}
}
display();
}
int chkprocess(int s)
29
int i;
for(i = 1; i <= s; i++)
{
if(process[i].rem != 0)
return 1;
}
return 0;
}
int nextprocess()
{
int min, l, i;
min = 0;
for(i = 1; i <= no; i++)
{
if( process[i].rem!=0 && process[i].pri > min)
{
min = process[i].pri;
l = i;
}
}
return l;
}
void display()
{
int i;
printf("\n\n\t\t\t---PRIORITY SCHEDULING---");
printf("\n\n Process Arrival Burst Priority Starting Waiting Finishing
turnaround Tr/Tb \n");
printf("%5s %9s %7s %15s %10s %8s %9s\n\n", "id", "time", "time", "time",
"time", "time", "time");
for(i = 1; i <= n; i++)

{
process[i].turnaround = process[i].wait + process[i].burst;

process[i].ratio
=
(float)process[i].turnaround
(float)process[i].burst;
printf("%5d %8d %7d %4d %7d %8d %10d %9d %10.1f ", process[i].id,
process[i].arrival,
process[i].burst,
process[i].pri,process[i].start,
process[i].wait,
process[i].finish,
process[i].turnaround,
process[i].ratio);
printf("\n\n");
}
}
4.10 Gruparea prioritilor

procesele pot fi grupate n clase de prioriti
se va utiliza priority scheduling ntre clase cu diferite prioriti
n cadrul fiecrei clase se va utiliza round-robin (ntre procese cu acelai
prioritate)
30
Priority inversion
o problem mare la algoritmii bazate pe prioriti este posibilitate
apariiei fenomenului de inversare a prioritilor
dac un proces prioritar ateapt dup un proces mai puin prioritar
(pentru sincronizarea
seciunilor critice), atunci procesele cu prioriti intermediare vor bloca
procesul prioritar astfel devenind aparent mai prioritari
soluia poate fi schimbarea temporare a prioritii procesului la
prioritatea celui care este blocat n ateptarea sincronizrii
Multiple queues
se folosesc clase de prioriti
procesele din clasa cea mai prioritar vor avea o cuant de timp, cele
din urmtoarea clas 2 cuante, urmtoarea 4 cuante, .a.m.d.
dac un proces i-a utilizat toate cuantele dintr-o clas, va fi trecut ntr-o
clas inferioar
de ex. un proces necesit 100 cuante:
ruleaz 1 cuant, ntrerupt, dup care 2, 4, 8, 16, 32, 37 t=> 7 comutri
n loc de 100
un proces lung se va rula din ce n ce mai rar
Shortest job first

algoritmii de pn acum au fost proiectai pentru sisteme interactive
algoritmul SJF este proiectat pentru sisteme n care timpul de rulare este
cunoscut n avans
de exemplu patru procese de aceeai prioritate:
mtF C F S t= 14, mtS J F t= 11
primul job rulat contribuie cel mai mult la mt
Procese: A B C D
Timp execuie: 8 4 4 4
SJF conduce la un timp de rspuns mediu minim
ar fi bine de utilizat i la procese interactive
problema: cum se estimeaz timpul de rulare pentru astfel de procese
ageing:
timpul iniial estimat t= T0, dup rulare timpul msurat t= T1
urmtoarea estimare t= aT0 + (1 a)T1
T0, T0/2 + T1/2, T0/4 + T1/4 + T2/2, T0/8 + T1/8 + T2/4 + T3/2
SJF este optim doar dac toate job-urile sunt disponibile
dac iniial numai A i B pot fi planificate, restul
fiind blocate: mt t= 4.6
31
dac toate procesele pot fi planificate: mt t= 4.4
import java.io.*;
class sjf
{
public static void main (String args[])throws IOException
{
int i,j,temp;
BufferedReader b= new BufferedReader(new InputStreamReader(System.in));
System.out.println("Enter no. of processes");
int p=Integer.parseInt(b.readLine());
int burst[]=new int[p];
System.out.println("Enter the burst time for each process");
for(i=0;iburst[j+1])
{
temp=burst[j+1];
burst[j+1]=burst[j];
burst[j]=temp;
}
}
}
int arv[] = new int[p];
System.out.println("Enter arrival time for each process");
for(i=0;i arv[i]=Integer.parseInt(b.readLine());
int wait[] = new int[p];
System.out.println("Wait time for each process :");
System.out.println("Process 0 "+wait[0]+" units");
for(i=1;i {
wait[i]=arv[i-1]+burst[i-1]+wait[i-1]-arv[i];
System.out.println("Process "+i+" "+wait[i]+" units");
}
}
}
Planificare garantat
o abordare diferit de planificare:
se face promisiuni utilizatorului legat de mrimea timpului CPU atribuit
32
de exemplu dac sunt n utilizatori logai n sistem, fiecare va primi 1/n

din timpul CPU
sistemul calculeaz mereu ct timp CPU a utilizat fiecare utilizator i
mparte cu n, apoi calculeaz raportul ntre timpul utilizat i timpul de la
ultimul calcul
ruleaz tot timpul procesul cu cel mai mic raport
Politici i mecanisme
nici unul din algoritmii prezentai nu acceptau informaii de la procesele
utilizator, pe care s le foloseasc n luarea deciziilor
schedulerul nu va lua ntotdeauna decizia cea mai bun
soluia este separarea mecanismului planificrii de politica planificrii
mecanismul este realizat de kernel, dar politica este stabilit de
procesul utilizator
algoritmul de planificare este parametrizat ntr-un anume mod astfel
nct parametrii s pot fi setai de procesele utilizator
kernelul folosete priority scheduling i asigur un apel sistem prin care
un proces poate seta prioritile proceselor fii, astfel procesul printe va
controla planificarea proceselor fii
Two-level scheduling
pn acum am presupus c procesele ready se afl n memorie
dac ns nu dispunem de suficient memorie, unele din procese ready
va trebui plasate pe disc
comutarea proceselor de pe disc va lua un timp mult mai mare dect
celor din memorie
vom utiliza un scheduler cu 2 niveleTwo-level scheduling
iniial o submulime a proceselor ready vor fi ncrcate n memorie
schedulerul va planifica numai aceste procese pentru o perioad de
timp
periodic un scheduler de nivel nalt este utilizat pentru a elimina
procesele din memorie (care sunt de mult timp acolo) i a ncrca procese
noi de pe disc
apoi se folosete schedulerul de nivel jos pentru planificare ntre aceste
procese noiCriteriile folosite de schedulerul de nivel nalt
ct de mult a stat un proces n memorie sau pe disc
ct timp CPU a utilizat procesul
ct de mare este procesul
care este prioritatea procesului
import java.util.LinkedList;
class Test {
public static void main(String args[]) {
33
char arr[] = {3,1,4,1,5,9,2,6,5,3,5,8,9};

LinkedList<Integer> fifo = new LinkedList<Integer>();
for (int i = 0; i < arr.length; i++)
fifo.add (new Integer (arr[i]));
System.out.print (fifo.removeFirst() + ".");
while (! fifo.isEmpty())
System.out.print (fifo.removeFirst());
System.out.println();
}
Capitolul 5: Problema optimizare

34
5.1 Modelul problemei de planificare
Elemente de teoria ordonanei

O problem de ordonanare const n stabilirea unei ordini de efectuare a operaiilor
(activitilor) unui proiect, astfel ca interdependenele dintre ele s fie respectate n cadrul
resurselor disponibile i durata total de execuie a acestuia s fie minim.
Pentru a putea concretiza definiia de mai sus, trebuie clarificate noiunile de proiect,
operaii (activiti) ale acestuia, interdependene ntre operaii i resurs a proiectului.
Prin proiect vom nelege o aciune de mare amploare sau un proces complex destinat
atingerii unui scop bine precizat. La un proiect deosebim urmtoarele caracteristici: un
obiectiv (care poate fi un produs, o cantitate de informaii sau un rezultat de natur
organizatoric), un ansamblu de activiti (subaciuni, subprocese, operaii), corelate logic i
tehnologic, a cror realizare permite atingerea scopului propus i un proces tehnologic prin
care se precizeaz intercondiionrilor ntre activiti, interesnd n special ordinea de execuie
a acestora.
Pentru a permite o analiz amnunit a desfurrii lui, o alegere a variantelor optime
de execuie i un control continuu al evoluiei sale, trebuie s descompunem proiectul n pri
componente la un nivel care s permit tratarea unitar a fiecrei pri i stabilirea
conexiunilor ntre acestea. Aceste componente se numesc operaii sau activiti.
O activitate este o parte distinct dintr-un proiect, un subproces precis determinat, care
consum timp i resurse. Vom presupune n continuare c activitile au urmtoarele
proprieti: fiecare activitate este indivizibil (nu se mai descompune n subactiviti), fiecare
activitate are o durat cunoscut i, odat nceput, nu mai poate fi ntrerupt.
Dintre intercondiionrile (interdependenele) dintre activiti, ne intereseaz, n
special, cele temporale, numite relaii de preceden, care pot fi de trei tipuri:
1. Relaii de preceden de tip "terminare nceput" Acest tip este cel mai frecvent
ntlnit i spunem c o activitate A precede activitatea B printr-o interdependen de
tip "terminare nceput" dac activitatea B nu poate ncepe dect dup un interval de
timp tAB de la terminarea activitii A. Acest interval poate fi egal i cu zero, caz n
care spunem c activitatea A precede direct activitatea B.
35
2. De tip "nceput nceput" Acest tip este frecvent ntlnit i spunem c o activitate A
precede activitatea B printr-o interdependen de tip "nceput nceput" dac
activitatea B nu poate ncepe dect dup un interval de timp tAB de la nceperea
activitii A. Acest interval poate fi chiar mai mare dect durata activitii A, caz n
care avem de fapt o dependen de tipul "terminare nceput", putnd chiar privi
primul tip ca un caz particular al celui de-al doilea.
3. De tip "terminare terminare". Spunem c o activitate A precede activitatea B printr-o
interdependen de tip "terminare terminare" dac activitatea B nu se poate termina
dect dup un interval de timp tAB de la terminarea activitii A sau c activitatea A
trebuie terminat cu cel puin tAB uniti de timp naintea terminrii activitii B.
Prin durat total de execuie a unui proiect nelegem intervalul de timp n care se
efectueaz toate activitile acestuia, respectnd toate interdependenele dintre activiti.
A programa un proiect nseamn a stabili termenele de ncepere pentru fiecare
activitate n parte, innd seama de restriciile impuse de procesul tehnologic, duratele
activitilor i resursele disponibile. Pentru un proiect dat, exist un numr enorm de
programri admisibile. Un interes deosebit prezint programul optim, adic acel program
care, pe de o parte, satisface restriciile impuse iar, pe de alt parte, optimizeaz un anumit
criteriu de eficien economic.
Criteriul de optimizare nu este acelai pentru toate proiectele, el este stabilit pentru
fiecare caz n parte i definete obiectivele majore ale conducerii proiectului. n funcie de
aceste obiective, criteriul poate fi durata total minim, costul total minim, folosirea ct mai
uniform a resurselor sau o sintez a acestora. Deci, programul optim este acea desfurare a
proiectului, precizat prin termenele de ncepere ale activitilor, care conduce la o eficien
maxim. [9]
Problema planificrii implic utilizarea unui graf orientat, aciclic, care s conin o
colecie de activiti i datele referitoare la relaiile lor de preceden. Scopul planificrii
activitilor este de a elimina momentele din proiect fr activiti i de a optimiza organizarea
activitilor, astfel nct relaiile de preceden s se ndeplineasc, iar timpul total de execuie
s fie minim. [10] n general, problema planificrii resurselor este de dou tipuri: static i
dinamic.
n planificarea static, caracteristicile problemei, cum ar fi durata unei activiti,
legturile, precedenele sau sincronizarea sunt cunoscute nainte de a fi executate. Pe de alt
parte, n planificarea dinamic, sunt cunoscute puine activiti i deciziile cu privire la
36
acestea sunt luate pe pacrurs. n continuare este prezentat modelul static de programare a
resurselor. [11]
Analiza resurselor
Dac din punct de vedere al condiionrilor de tip preceden (temporale) existena
activitilor paralele este corect din punct de vedere logic, putnd exista oricte activiti care
se desfoar n acelai timp, dac nu se intercondiioneaz ntre ele, neexistnd nici o
diferen ntre zilele proiectului, din punct de vedere practic, este clar c o zi n care se
desfoar n acelai timp 10 activiti este mult mai intens din punct de vedere al organizrii
i aprovizionrii cu resurse dect o zi n care se desfoar o singur activitate. Deci, dac se
ine cont doar de condiionrile temporale pot aprea dezechilibre foarte mari n desfurarea
proiectului i/sau pot aprea zile n care necesarul de resurse ar fi mai mare dect disponibilul
acestora.
Din cele spuse mai sus, se desprinde faptul c exist cel puin dou probleme
importante legate de resursele unui proiect:
problema alocrii resurselor, n care se ncearc programarea activitilor n aa fel
nct n nici o zi s nu se depeasc disponibilul din nici o resurs;
problema nivelrii resurselor, n care se ncearc programarea activitilor n aa
fel nct n toate zilele s se foloseasc cam aceiai cantitate de resurse (sau, altfel spus, suma
variaiilor de la o zi la alta s fie minim).
Analiza n cele dou probleme de mai sus se face n general pentru resurse refolosibile,
care nu se consum n timp, adic cele care, dup terminarea activitii la care au fost alocate,
se pot folosi la alt activitate. Resursele de acest tip sunt n principal fora de munc i
mainile i utilajele. [9]
5.2 Descrierea matematic a problemei

Un proiect va consta ntr-un set de activiti V = (1, 2, ..., n). Activitatea 1 i activitatea
n reprezint nceputul proiectului, respectiv sfritul proiectului.
37
Pentru fiecare activitate j vom nota cu Predj mulimea activitilor care trebuie s se
finalizeze nainte ca j s nceap. Elementele mulimii Predj sunt numite predecesori direci ai
lui j. Astfel, este adevrat urmtoarea afirmaie generalizat:
O
activitate
este
numit
predecesoare
activitii
dac
exist
.
Activitatea i este un succesor imediat al activitii j dac j este un predecesor imediat

al activitii i. Mulimea tuturor succesorilor o vom nota cu Sucj. Astfel, activitatea 1 va fi
predecesor pentru toate activitile, respectiv activitatea n va fi succesor pentru toate
activitile proiectului.
Un alt tip de restricie se refer la resurse. Sunt definite un numr de K tipuri de
resurse refolosibile. O cantitate limitat din k resurse, notat cu Rk, este disponibil n fiecare
unitate de timp. n timpul desfaurrii unei activiti j, sunt necesare rjk uniti de resurs
, pe parcursul fiecrei perioade te timp de durat dj (exist un singur mod de
desfurare a activitilor). Se consider, de asemenea, ca activitile nu pot fi oprite o dat de
au nceput.
Parametri Rk,, rk, dj se presupun a fi cunoscui sau determinai, de tip ntreg. De
asemenea, r1k = rnk = 0 i d1j = dnj = 0, pentru toi
Problema planificrii acivitilor i resurselor se poate rezolva dac timpul de nceput

(sau timpul de sfrit) a fiecrei activiti satisface restriciile de preceden i cele referitoare
la resurse, astfel nct timpul total de desfurare al proiectului s fie minim.[12]
Un exemplu de proiect, definit pe baza notaiilor de mai sus, se regsete n figura 3.1.
Acest proiect are n = 7 activiti i k = 1 resurse reutilizabile, cu 2 uniti capacitate.
38
Fig. 3.1
di/rj,1
2/
1
1/
2
0/
0
0/
0
K = 1, R1
=2
1/
2
1/
1
2/
1
n figura 3.2, o secven posibil este reprezentat cu o durat total de 8 unit i de

timp, n timp ce n figura 3.3 este reprezentat o aranjare a activitilor ce determin o durat
total de doar 5 uniti de timp. Aceste secvene sunt reprezentate cu ajutorul diagramei Gantt.
Axa orizontal reprezint timpul, iar axa vertical utilizarea resurselor. Dac ar fi existat mai
multe tipuri de resurse, era necesar realizarea unei diagrame pentru fiecare resurs n parte.
Fiecare dreptunghi reprezint o activitate. Lungimea dreptunghiului reprezint durata
activitii, iar nlimea arat numrul de uniti de resurs folosit pentru activitate.
Fig.
3.2
Fig.
3.3
39
6
2
Definiii:
Cu sj (fj) vom nota nceputul (sfritul) activitii j n secvena S, astfel rezultnd un
vector de timpi de start (s1, s2, ..., sn), sau similar, un vector de timpi de final (f1, f2, ..., fn). s1 =
0, iar sn = max {
}. fn va fi lungimea sau durata proiectului, n cazul n care nu este
specificat altfel. Dac o secven va fi fezabil, va fi notat cu T(s) i va fi definit ca solu ie

admisibil, care ndeplinete toate restriciile de preceden i constrngerile privind resursele.
O secven S dat,
, este o activitate activ la momentul t.
Funcia obiectiv (3.1) minimizeaz timpul de finalizare a activitilor proiectului, adic
durata proiectului. Restriciile (3.2) reprezint relaiile de preceden, iar restriciile (3.3)
reprezint limita utilizrii fiecrei resurse k la momentul t. n final, restriciile (3.4) definesc
variabilele de decizie ca fiind ntregi, nenegative. [12]
5.3 Metode clasice de rezolvare

Algoritmii genetici nu reprezinta metoda principala n rezolvarea problemelor de
planificare a activitilor i a resurselor unui proiect. Deoarece situaiile din practic ce
necesit rezolvarea unei probleme de ordonanare sunt foarte variate, s-au propus numeroase
modele pentru rezolvarea lor. n continuare vor fi prezentate cteva dintre modelele cele mai
frecvent utilizate n practic.
1. Modele de analiz a drumului critic (ADC)

Principiul analizei drumului critic const n divizarea unui proiect (aciuni complexe)
n pri componente, la un nivel care s permit corelarea logic i tehnologic a acestora,
adic s fac posibil stabilirea interaciunilor ntre prile componente. Aceste pri
componente sunt activitile aciunii complexe.
La definirea listei de activiti specialistul sau specialitii care particip la aceast
operaie folosesc experiena lor pentru a rspunde pentru fiecare activitate la ntrebrile: ce
alte activiti succed sau preced n mod necesar aceast activitate?; care este durata
activitii?. Ia natere n acest fel un tabel care conine activitile proiectului,
intercondiionrile ntre activiti i duratele acestora.
40
Un astfel de tabel trebuie s conin cel puin urmtoarele elemente:

activiti: n aceast coloan se enumer activitile proiectului, fiind puse n eviden
printr-o denumire sau printr-un simbol (codul activitii);
condiionri: se precizeaz, pentru fiecare activitate, activitile imediat precedente,
prin simbolurile lor; activitile de start nu au activiti precedente, n csu fiind
trecut o liniu;
durata: pentru fiecare activitate se precizeaz durata de execuie, ntr-o anumit unitate
de msur. Durata unei activiti este o constant.
Modelele de analiz a drumului critic se bazeaz pe reprezentarea proiectului printr-un
graf, elementele tabelului asociat acestuia fiind suficiente pentru a construi graful
corespunztor.
Exist mai multe moduri de a reprezenta un proiect printr-un graf, cele mai cunoscute
fiind prezentate mai jos:
A. Metoda CPM (Critical Path Method)

Metoda CPM este un procedeu de analiz a drumului critic n care singurul parametru
analizat este timpul i n reprezentarea graficului reea se ine seama de urmtoarele convenii:
fiecrei activiti i se asociaz un segment orientat numit arc, definit prin capetele sale,
astfel fiecare activitate identificndu-se printr-un arc;
fiecrui arc i se asociaz o valoare egal cu durata activitii pe care o reprezint;
condiionarea a dou activiti se reprezint prin succesiunea a dou arce adiacente.
Nodurile grafului vor reprezenta momentele caracteristice ale proiectului, reprezentnd
stadii de realizare a activitilor (adic terminarea uneia sau mai multor activiti i/sau
nceperea uneia sau mai multor activiti).
Procedeul CPM se bazeaz pe existena unei corespondene bipartide ntre elementele
unui proiect (activiti, evenimente) i elementele unui graf (arce i noduri). Se obine o
relaie model-obiect, care pune n eviden particularitile de o mare nsemntate practic, n
special, proprietile de succesiune temporal.
Printre avantajele metodei CPM (i n general ale analizei drumului critic) evideniem:
determinarea cu anticipaie a duratei de execuie a proiectelor complexe;
pe timpul desfurrii proiectului permite un control permanent al execuiei
acestuia;
41
explicitarea legturilor logice i tehnologice dintre activiti;

evidenierea activitilor critice;
evidenierea activitilor necritice, care dispun de rezerve de timp;
permite efectuarea de actualizri periodice fr a reface graful;
ofer posibilitatea de a efectua calcule de optimizare a duratei unui proiect, dup
criteriul costului;
reprezint o metod operativ i raional care permite programarea n timp a
activitilor innd seama de resurse.
Dezavantajele acestei metode sunt n principal:
greutatea desenrii grafului, fiind foarte greu de reprezentat exact toate
condiionrile din proiect, n condiiile n care acestea sunt foarte complicate iar
desenul trebuie s fie destul de simplu i clar nct s fie inteligibil i deci util;
chiar dac se respect toate regulile de construire a grafului, rmn nc destule
variante de desenare astfel nct dou reprezentri ale aceluiai proiect fcute de
doi indivizi pot s nu semene aproape deloc.
din cele de mai sus se vede c reprezentarea este greoaie chiar dac toate
condiionrile ar fi de tipul "terminare nceput" cu preceden direct, ncercarea
de a forma graful n condiiile existenei i a celorlalte tipuri de interdependene
ducnd foarte repede la un desen extrem de ncrcat i greu de folosit.
B. Metoda MPM (Metro Potenial Method)

Metoda potenialelor sau MPM este un procedeu de analiz a drumului critic care
ncearc s depeasc neajunsurile metodei CPM, n care, ca i n metoda CPM, se
analizeaz parametrul timp, diferena constnd n felul n care se construiete graful reea:
fiecrei activiti A i se asociaz un nod A;
fiecrui nod i se asociaz o valoare dat de durata activitii pe care o reprezint;
condiionarea (succesiunea) a dou activiti se reprezint printr-un arc, orientat de la o
activitate la alta;
fiecrui arc dintre dou activiti A i B i se asociaz un numr reprezentnd valoarea tAB.
Reprezentarea activitate nod permite ca ntre activitile unui proiect s avem mai
multe tipuri de legturi de preceden (terminare nceput, nceput nceput, terminare
terminare).
2. Grafuri ADC integrate i condensate

42
n practica managementului aciunilor economice complexe prim metodele ADC,

nivelul de detaliere n activiti a proiectelor depinde de scopul urmrit (coordonare de
ansamblu sau conducere de detaliu), de timpul avut la dispoziie pentru elaborarea grafurilor,
de specialitii disponibili etc.
Dac graful sumar care se ntocmete pentru orientarea general a echipei de
conducere a aciunii (graf director) este totdeauna necesar, cnd se face trecerea la conducerea
de amnunt, sunt tot att de necesare grafurilor detaliate.
n general grafurile detaliate se fac pe pri din aciunea complex, numite obiective
sau obiecte. Astfel, dac ne referim de exemplul la un proiect de construcii, graful
corespunztor ntregului proiect poate fi divizat n grafuri pe obiect, cum ar fi:
graful proiectrii;
graful organizrii antierului;
unul sau mai multe grafuri pentru lucrri de drumuri;
mai multe grafuri pentru lucrri de reele (ap, canal abur, electrice etc.);
mai multe grafuri pentru lucrri de construcii-montaj (cte unul pentru fiecare hal
sau cldire) etc.
Grafurile pe obiect au individualitatea lor i se trateaz ca entiti de programare
distincte; n acelai timp ns, trebuie gndit coordonarea lor n cadrul aciunii complexe din
care fac parte. n acest scop, dup ntocmirea separat a grafurilor pe obiect apare necesitatea
asamblrii lor ntr-un tot, care constituie graful integrat.
n foarte multe cazuri din practic, numrul activitilor care rezult prin integrarea
mai multor grafuri pe obiect este considerabil, putnd ajunge la zeci de mii, ceea ce depete
de multe ori posibilitatea de a le calcula i urmri, chiar cu ajutorul calculatoarelor puternice.
Cu att mai puin ar fi posibil cuprinderea sintetic a unui asemenea graf la nivelul
conducerii ntregii aciuni.
Pentru aceste motive a fost necesar gsirea unui mijloc de a reduce graful integrat,
pstrndu-i n acelai timp principalele caracteristici. Aceast operaie poart numele de
condensare iar rezultatul aplicrii acesteia asupra unui graf se numete graf condensat.
3. Actualizarea grafurilor ADC

43
n practica realizrii aciunilor complexe, sunt numeroase cazurile cnd estimrile

iniiale de durat ale activitilor nu pot fi respectate. Apare astfel necesitatea ca, periodic, s
se examineze modul cum se realizeaz termenele calculate, n scopul punerii n eviden a
eventualelor ntrzieri i a lurii msurilor de recuperare a acestora.
Aceast activitate poart numele de actualizare a grafurilor iar noul graf se numete
graf actualizat.
4. Optimizri cost-durat
Estimarea duratelor aciunilor complexe (problema ADC/TIMP) prin metodele expuse
mai nainte, dei reprezint o problem deosebit de important din punct de vedere economic,
nu este nici pe departe singurul aspect care poate fi urmrit cu ajutorul acestor metode.
O alt problem n care pot fi utilizate instrumentele ADC sunt cele de analiz a
costului execuiei aciunilor complexe, n funcie de durata de execuie a acesteia.
Este evident c, n funcie de pregtirea celor care efectueaz lucrarea, de tehnologia
folosit, de oportunitile momentului etc, durata de execuie a unei aciuni complexe poate
varia, existnd totui o durat minim posibil Tmin i una maxim Tmax acceptabil.
Evident, durata lucrrii are numeroase implicaii asupra costului, drept pentru care
prezint un deosebit interes determinarea acelei durate de execuie, intermediare lui Tmin i
Tmax, creia i corespunde costul minim.
5. Graficul Gantt
Un instrument de mare utilitate n analiza drumului critic l constituie graficul
calendaristic tip Gantt, aprut la nceputul secolului. Graficul (diagram) Gantt exprim la
scara timpului, prin linii orizontale, durata activitilor, i prin linii ntrerupte (de exemplu)
rezervele de timp. Graficul Gantt presupune divizarea aciunii complexe pe care o reprezint
proiectul, n pri componente (activiti) i ealonarea acestora n timp, innd seama de
succesiunea tehnologic, termene impuse, resurse etc.
Dac este ntocmit n urma unei analize temeinice, graficul Gantt ofer informaii
bogate i extrem de sugestiv prezentate, privind desfurarea lucrrilor, precum i o serie de
informaii derivate, privind ealonarea resurselor (for de munc, materii prime, materiale,
fonduri bneti). Aceste avantaje scad dac, datorit fie amplorii aciunii considerate, fie
nivelului de detaliere dorit, numrul activitilor ce compun graficul Gantt crete mult,
ajungnd la cteva sute sau mii.
44
Graficul Gantt exprim la scara timpului un program de ordonanare. Astfel, avem

graficul Gantt la termenele cele mai devreme sau graficul Gantt la termenele cele mai trzii.
6. Analiza resurselor
Dac din punct de vedere al condiionrilor de tip preceden (temporale) existena
activitilor paralele este corect din punct de vedere logic, putnd exista oricte activiti care
se desfoar n acelai timp, dac nu se intercondiioneaz ntre ele, neexistnd nici o
diferen ntre zilele proiectului, din punct de vedere practic, este clar c o zi n care se
desfoar n acelai timp 10 activiti este mult mai intens din punct de vedere al organizrii
i aprovizionrii cu resurse dect o zi n care se desfoar o singur activitate. Deci, dac se
ine cont doar de condiionrile temporale pot aprea dezechilibre foarte mari n desfurarea
proiectului i/sau pot aprea zile n care necesarul de resurse ar fi mai mare dect disponibilul
acestora.Din cele spuse mai sus, se desprinde faptul c exist cel puin dou probleme
importante legate de resursele unui proiect: problema alocrii resurselor, n care se ncearc
programarea activitilor n aa fel nct n nici o zi s nu se depeasc disponibilul din nici o
resurs i problema nivelrii resurselor, n care se ncearc programarea activitilor n aa
fel nct n toate zilele s se foloseasc cam aceiai cantitate de resurse (sau, altfel spus, suma
variaiilor de la o zi la alta s fie minim).
Trebuie fcut i observaia c analiza n cele dou probleme de mai sus se face n
general pentru resurse refolosibile, care nu se consum n timp, adic cele care, dup
terminarea activitii la care au fost alocate, se pot folosi la alt activitate. Resursele de acest
tip sunt n principal fora de munc i mainile i utilajele.
7. Metoda PERT
Metodele CPM i MPM analizate anterior furnizeaz, aa cum s-a vzut, informaii
care sunt utile n procesul de conducere, ns ele nu in seama de posibilele variaii ale
duratelor de execuie ale activitilor.
Metoda PERT ncearc s corecteze acest lucru. n acest scop metoda permite
calcularea timpului mediu de terminare a unui proiect, identificarea activitilor critice,
precum i estimarea probabilitilor de realizare a termenelor planificate. Pentru c n
practic, n foarte multe programe din domeniul cercetrii i dezvoltrii, duratele activitilor
sunt insuficient cunoscute sau chiar incerte prin considerarea conceptelor statistice, duratele
activitilor sunt considerate variabile aleatoare caracterizate prin media i dispersia lor. [9]
45
Aplicatie
46
Programarea ocuparii unei camere de o persoana printr-un algoritm de tip greedy.

Aplicatie realizata in Java.
import java.io.*;
import java.util.*;
public class Schedule
{
private ArrayList<Event> events;
private int numEvents;
public Schedule()
{
events = new ArrayList<Event>();
numEvents = 0;
}
public int getNumEvents()
{
return numEvents;
}
/*incearca sa programeze un eveniment daca se poate programa este pus in lista array cu
evenimente*/
public void scheduleEvent(Evente)
{
int[] conflictList = conflict(e);
/* if event e can't be added, just return */
if (conflictList == null)
return;
/* remove any events that conflict */
for (int i=conflictList.length-1; i>=0; i--)
{
events.remove(conflictList[i]);
numEvents--;
}
/* add this event to the list */
events.add(e);
numEvents++;
}
/*expunerea datelor intr-un table*/

public String toString()
{
47
int maxEventLength, maxContactLength;

maxEventLength = maxContactLength = -1;
/* convert array list to array, get max lengths */
Event[] eventsArr = new Event[numEvents];
for (int i=0; i<numEvents; i++)
{
eventsArr[i] = events.get(i);
if (eventsArr[i].getName().length() > maxEventLength)
maxEventLength = eventsArr[i].getName().length();
if (eventsArr[i].getCoordinator().getName().length() >
maxContactLength)
maxContactLength =
eventsArr[i].getCoordinator().getName().length();
}
/* sort events by starting time */
Arrays.sort(eventsArr);
String s = "";
/* output table */
s += "Event";
for (int i="Event".length(); i<maxEventLength+1; i++)
s += " ";
s += "Start Time End Time Organizer";
for (int i="Organizer".length(); i<maxContactLength+1; i++)
s += " ";
s += "Age\n";
for (int i=0; i<maxEventLength; i++)
s += "-";
s += " ---------- -------- ";
for (int i=0; i<maxContactLength; i++)
s += "-";
s += " ---\n";
for (int i=0; i<numEvents; i++)
{
s += eventsArr[i].getName();
for (int j=eventsArr[i].getName().length(); j<maxEventLength;
j++)
s += " ";
s += " " +
String.format("%02d",eventsArr[i].getStartTime().getHours()) + ":" +
String.format("%02d",eventsArr[i].getStartTime().getMinutes());
s += "
"+
String.format("%02d",eventsArr[i].getFinTime().getHours()) + ":" +
String.format("%02d",eventsArr[i].getFinTime().getMinutes());
s += " " + eventsArr[i].getCoordinator().getName();
for (int j=eventsArr[i].getCoordinator().getName().length();
j<maxContactLength; j++)
s += " ";
s += " " + eventsArr[i].getCoordinator().getAge();
s += "\n";
48
}
return s;
}
/*determinarea unui conflict intre evenimente*/
private int[] conflict(Event e)
{
int thisStartTime = e.getStartTime().totalminutes();
int thisEndTime = e.getFinTime().totalminutes();
ArrayList<Integer> conflictList = new ArrayList<Integer>();
for (int i=0; i<events.size(); i++)
{
int thatStartTime = events.get(i).getStartTime().totalminutes();
int thatEndTime = events.get(i).getFinTime().totalminutes();
/* if the event.get(i) has a conflicting time */
if ((thisStartTime < thatStartTime && thisEndTime >
thatStartTime) ||
(thisStartTime >= thatStartTime && thisEndTime <=
thatEndTime) ||
(thisStartTime < thatEndTime && thisEndTime >=
thatEndTime)
||
(thisStartTime <= thatStartTime && thisEndTime >=
thatEndTime))
{
/* if this events age is greater, add this event to
conflictList */
if (e.contactIsOlder(events.get(i)))
conflictList.add(i);
else
return null;
}
}
/* put conflicts in int[], return */
int[] cL = new int[conflictList.size()];
for (int i=0; i<cL.length; i++)
cL[i] = conflictList.get(i);
return cL;
}
/* metoda principala */
public static void main(String[] args) throws FileNotFoundException
{
Scanner stdIn = new Scanner(System.in);
System.out.print("Input file> ");
String fileIn = stdIn.next();
49
Scanner fIn = new Scanner(new File(fileIn));

int n = fIn.nextInt();
fIn.nextLine(); // used to get rid of newline after n
Schedule sched = new Schedule();
/* programarea evenimentului */
for (int i=0; i<n; i++)
{
String eventName = fIn.nextLine();
Time2 startTime = new Time2(fIn.nextInt(),fIn.nextInt());
fIn.nextLine();
Time2 finishTime = new Time2(fIn.nextInt(),fIn.nextInt());
fIn.nextLine();
String eventContactName = fIn.nextLine();
int a = fIn.nextInt();
int m = fIn.nextInt();
int d = fIn.nextInt();
int phoneNumber = fIn.nextInt();
Contact eventContact = new
Contact(eventContactName,a,phoneNumber,m,d);
if (fIn.hasNextLine())
fIn.nextLine();
sched.scheduleEvent(new
Event(eventName,startTime,finishTime,eventContact));
}
/* output solution */
System.out.println(sched);
}
}
/* clasa Event, clasa ce implementeaza Comparable */

class Event implements Comparable<Event>
{
private String name;
private Time2 start, fin;
private Contact coord;
/* create new Event */
public Event(String n, Time2 s, Time2 f, Contact c)
{
name = n;
start = s;
fin = f;
coord = c;
}
public String getName()
{
return name;
}
50
public Time2 getStartTime()

{
return start;
}
public Time2 getFinTime()
{
return fin;
}
public Contact getCoordinator()
{
return coord;
}
/* verificam daca contactul recent este mai vechi decat cel din evenimentul e*/
public boolean contactIsOlder(Event e)
{
Contact thisContact = coord;
Contact thatContact = e.getCoordinator();
/* daca varsta este mai mare */
if (thisContact.getAge() > thatContact.getAge())
return true;
/* returneaza data recenta */
Calendar today = Calendar.getInstance();
int thisMonth = today.get(Calendar.MONTH)+1; // offset by 1 since
JANUARY == 0
int thisDay = today.get(Calendar.DAY_OF_MONTH);
/* verificam ce zile au trecut */
boolean thisBdayPassed, thatBdayPassed;
thisBdayPassed = thatBdayPassed = false;
if (((thisContact.getBdayMonth() < thisMonth) ||
(thisContact.getBdayMonth() == thisMonth && thisContact.getBdayDay() <= thisDay)))
thisBdayPassed = true;
if (((thatContact.getBdayMonth() < thisMonth) ||
(thatContact.getBdayMonth() == thisMonth && thatContact.getBdayDay() <= thisDay)))
thatBdayPassed = true;
/* daca varsta este identica corelam programarea la zilele de nastere */
if (thisContact.getAge() == thatContact.getAge())
{
/* trei cazuri:
*
1) amandoua zilele au trecut
51
*
*
2) nici una din zile nu a trecut

Observatie cazurile 1 si 2 realizeaza aceasi
verificare
*
3a) this a trecut, that nu a trecut
*
3b) that a trcut, this nu a trecut
*/
/* cazurile 1 & 2*/
if ((thisBdayPassed && thatBdayPassed) || (!thisBdayPassed &&
!thatBdayPassed))
{
if (thisContact.getBdayMonth() <
thatContact.getBdayMonth())
return true;
if (thisContact.getBdayMonth() ==
thatContact.getBdayMonth())
if (thisContact.getBdayDay() <
thatContact.getBdayDay())
return true;
}
/* cazul 3 returneaza doar daca thatBday a trecut
*
daca a trecut, atunci this nu a trecut si este mai in varsta
*
daca nu a trecut, atunci this a trecut si este mai in varsta
*/
else
{
return thatBdayPassed;
}
}
return false;
}
/* sortam evenimentele programate */
public int compareTo(Event other)
{
if (start.getHours() == other.getStartTime().getHours())
return (start.getMinutes() - other.getStartTime().getHours());
return (start.getHours() - other.getStartTime().getHours());
}
}
Concluzii
Sistemele de planificare sunt algoritmi de rezolvare a problemelor
care opereaz cu reprezentri explicite ale strilor i actiunilor;
52
Algoritmii de planificare cu ordine partial sunt eficienti mai ales

asupra problemelor care pot fi descompuse;
Grafurile de planificare pot fi utilizate att ca euristici ct i ca suport
pentru extragerea direct a solutiilor de ctre algoritmi precum Graphplan;
RMS i DMS
-
usor de implementat pe nuclee tip comercial, care nu suporta in mod

explicit constrangeri de timp pentru setul de procese
utilizat pe scar larg n practic
dezavantaj: utilizarea limitat a resurselor
EDF i LLF
mai dificil de implementat

ofer o planificabilitate mai bun
avantaj: utilizarea la capacitate maxim a resurselor
implementat pe cateva sisteme distribuite
experimentale: Hartik, Shark , Erika , Spring , Yartos
de
timp-real
MUF
-
mai complex dpdv al implementarii fata de RMS i EDF

rezultate mai bune la teste, ns necesit resurse mai mari
detecia unor erori / ratari a timpilor limit n realizarea planificarii
Bibliografie
[1] Ioan RUS, Clin-Adrian COMES, Veronica DEAC Optimizarea fluxurilor informatice n
timp real element al restructurrii informatice, Universitatea Petru Maior din TrguMure
2010
53
[2] http://ro.wikipedia.org/wiki/Optimizare
[3] Romic Trandafir, Modele i algoritmi de optimizare, Ed. AGIR, Bucureti, 2004
[4] http://ro.wikipedia.org/wiki/Algoritm_genetic
[5] Claudia Mihaela Mark Seria informatic Algoritmi Genetici, Timioara, 2010
[6] Randy L. Haupt, Sue Hellen Haupt Practical Genetic Algorithms, John Wiley & Sons,
Inc., Hoboken, New Jersey, 2004
[7] Emil Scarlat, Nora Chirita - Cibernetica sistemelor economice, Editura ASE, Bucureti,.
2003
[8] Henri Luchian, Mihaela Breaban Algoritmi Genetici, Universitatea Al. I Cuza, Ia i,
2006
[9] E. ignescu, D. Mitru Bazele cercetrii operaionale, Ed. ASE, Bucureti 1999
[10] A. Abraham, A.E.Hassanien, P. Siarry, A. Engelbrecht - Foundations of Computational
Intelligence Volume 3
[11] F.A. Omara and M.M. Arafa - Genetic Algorithms for Task Scheduling Problem
[12] E.G. Franco, F.T. Zurrita, G.M. Delgadillo A Genetic Algorithm for the Resource
Constrained Project Scheduling Problem, Bogota
54

Licenta Time Scheduling POPESCU MARIAN ALEXANDRU MIHAI

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Licenta Time Scheduling POPESCU MARIAN ALEXANDRU MIHAI

Încărcat de

Drepturi de autor:

Formate disponibile

Universitatea Titu Maiorescu

Capitolul 1: Algoritmi Greedy

1.1 Noiuni introductive

multime de candidati (lucrari de executat, varfuri ale grafului etc)

Pentru a rezolva problema noastra de optimizare, cautam o solutie posibila care sa

candidatii: multimea initiala de monezi de 1, 5, si 25 unitati, in care

o solutie posibila: valoarea totala a unei astfel de multimi de monezi selectate

o multime fezabila: valoarea totala a unei astfel de multimi de monezi selectate

functia obiectiv: numarul de monezi folosite in solutie; se doreste minimizarea

1.2 Clase de metode de optimizare

1.3 Algoritmi iterativi i convergen

1.4 Clasificarea metodelor de optimizare

Capitolul 2: Tehnica Divide et Impera

Divide et impera este o tehnic de elaborare a algoritmilor care const n:

S presupunem c avem un algoritm A cu timp ptratic. Fie c o constant, astfel

Iat o descriere general a metodei divide et impera:

n general, se recomand o metod hibrid care const n:

array D[1..n, 1..n]

2.1 Cautare binara

function sequential(T[1 .. n], x)

Algoritmul necesit un timp n (1+r), unde r este indicele returnat; aceasta

Iat i versiunea iterativ a acestui algoritm:

Generm un arbore binar, conform urmtoarei metode recursive:

2.2 Branch & Bound

2.3 Arborii binari de cutare tip data

n cazul arborelui de cutare, nu mai este necesar o astfel de generalitate, deoarece

2.4 Arborele optim

Capitolul 3: ALGORITMI DE PROGRAMARE

Programarea dinamic, ca i metoda divide et impera, rezolv problemele combinnd

exist o singur decizie pentru a trece la o etap superioar;Determinarea unui drum ce

3.2 Programarea dinamic comparat cu tehnica GREEDY

Vom considera o problem clasic de optimizare:

Capitolul 4: Planificarea proceselor

schedulerul implementeaz un algoritm de planificare (scheduling

4.2 Criteriile planificrii

fairness: fiecare proces s ocupe procesorul n mod cinstit

4.3 Problemele planificatorului

4.4 Strategiile planificatorului

4.5 First Come First Served Scheduling

procesele continu pn la terminare sau blocare, moment n care

System.out.println("======DISPLAYING GANTT CHART======");

double aTT = (float)averageTTsum/numberOfProcess;

public void solveWaitingTime()

4.6 Round Robin Scheduling

public void testOne() {

4.7 Round Robin

4.8 Alegerea cuantei

stabilirea unei cuante mici va conduce la comutri multe scznd

4.9 Priority scheduling

for(i = 1; i <= n; i++)

process[i].turnaround = process[i].wait + process[i].burst;

4.10 Gruparea prioritilor

Shortest job first

dac toate procesele pot fi planificate: mt t= 4.4

de exemplu dac sunt n utilizatori logai n sistem, fiecare va primi 1/n

char arr[] = {3,1,4,1,5,9,2,6,5,3,5,8,9};

Capitolul 5: Problema optimizare

5.1 Modelul problemei de planificare

Elemente de teoria ordonanei

5.2 Descrierea matematic a problemei

Activitatea i este un succesor imediat al activitii j dac j este un predecesor imediat

Problema planificrii acivitilor i resurselor se poate rezolva dac timpul de nceput

n figura 3.2, o secven posibil este reprezentat cu o durat total de 8 unit i de

/expunerea datelor intr-un table/