Embed Size (px)
DESCRIPTION
Kuva 1.1. Hierarkkinen kone. Rekisterit:. yleisrekisterit R0 ja R1. ohjelmalaskuri PC (program counter). Käskyrekisteri INSTR:. OPCODE. ADDRESS. Kuva 1.2. Algoritmi 1.1. - PowerPoint PPT Presentation
Citation preview
Sovellus
Kääntäjä
Käyttöjärjestelmä
Laitteisto
Ohjelmointikieli
Virtuaalikone
Arkkitehtuuri
kerros rajapinta
Kuva 1.1. Hierarkkinen kone.
Kuva 1.2.
OPCODE ADDRESS
Rekisterit:
Käskyrekisteri INSTR:
yleisrekisterit R0 ja R1ohjelmalaskuri PC (program counter)
while ( true ) {INSTR = mem[PC]; // Hae käsky
PC = PC+1; // Päivitä ohjelmalaskuriaswitch ( INSTR.OPCODE ) {// Tässä kuvaamattomia käskyjä …case ST0: mem[INSTR.ADDR] = R0;// kirjoita rekisteri 0 muistiin
break;case LD0: R0 = mem[INSTR.ADDR];// lue rekisteri 0 muistista
break;case JMP: PC = INSTR.ADDR;// hyppää osoitteeseen
break;case READ_CR: lue reikäkortti// esimerkiksi 80 merkkiä osoitteeseen INSTR.ADDR;
break;}
}
Algoritmi 1.1.
Kuva 1.3. Työ reikäkorteilla.
$JOB seuraava työ
$END JOB
$RUN pgm
Ohjelman data
$LNK in=obj out=pgm
$JOB laskutustietoja
$FTN out=obj
Ohjelma
TYÖ
Kuva 1.4.
Muisti
Käyttäjän muistialueKäyttöjärjestelmän muistialue
Rajarekisteri FENCE
0 N-1
Algoritmi 1.2
while ( true ) {if (TIMER == 0) {
mem[10] = PC;PC = 0; USER_MODE = false;
}TIMER = TIMER-1;INSTR = mem[PC];PC = PC+1;switch ( INSTR.OPCODE ) {
// tässä kuvaamattomia käskyjä …case ST0:
if ( USER_MODE && INSTR.ADDR < FENCE ) {PC = 1; USER_MODE = false;
} else mem[INSTR.ADDR] = R0;
break;case LD0: R0 = mem[INSTR.ADDR];
break;case SVC:
mem[10] = PC;R1 = INSTR.ADDR; PC = 2;USER_MODE = false;break;
case RETI:USER_MODE = true;PC = mem[10];break;
case READ_CR:if ( USER_MODE ) {
PC = 1; USER_MODE = false;} else
lue kortti osoitteeseen INSTR.ADDR;break;
}}
Kuva 1.5.
0:1:2:
10:
FENCE:
K: SVC READseuraava käsky
JMP timer_intJMP errorJMP SVC_INT…
K+1
SVC_INT: switch( r1) {…case read:“suorita luku"RETI
1.
2.
3.
4.
sivu 22.
while ( CR_STATUS == BUSY ) ; // tyhjä silmukkaif ( "kortti alkaa merkillä $" ) {
… // käsitellään erikseen käyttöjärjestelmäkomennot} else {
siirrä kortti käyttöjärjestelmän puskurista sovelluksen alueelle;käynnistä seuraavan kortin luku (READ_CR);palaa sovellukseen (RETI);
}
Kuva 1.6.
1: laskentaTyö 1: luku 1: tulostus
2: laskentaTyö 2: luku 2: tulostus
3: laskentaTyö 3: luku 3: tulostus
4: laskentaTyö 4: luku
Työ 5: luku
Kuva 1.7.
Levy
Muisti
Sovellus
Puskuri
Puskuri
Puskuri Puskuri
Kortinkuvatiedostot rivinkuvatiedostot
kortin-
rivikirjoitinSpool_in Spool_out
lukija
Algoritmi 1.3.
while ( true ) {if ( "kello- tai I/O-keskeytys on tulossa" && !mask ) {
mem[10..13] = (PC, R0, R1, TIMER);R1 = "keskeyttäneen laitteen numero (0 = TIMER)";MASK = true;PC = 0; USER_MODE = false;
}TIMER = TIMER-1; INSTR = mem[PC];PC = PC+1;switch ( INSTR.OPCODE ) {
:case RETI:
USER_MODE = true; MASK = false;(PC, R0, R1, TIMER) = mem[10..13];break;
case SVC:USER_MODE = false; MASK = true;mem[10..13] = (PC, R0, R1, TIMER);R1 = INSTR.ADDR;PC = 2;break;
}}
Kuva 1.8.
0:1:2:
10:
FENCE:
K: LD1 AST1 B
JMP IO_INTJMP errorJMP SVC_INT…
K+1
IO_INT: switch ( r1) {…case CR:“spool_in”RETI
Kuva 1.9.
Levy
Muisti
Sovellusi
Sovellus1 Sovellus N
Swapper
Sovellus2 …
pääte 1pääte 2…pääte n
Käyttöj.
Algoritmi 1.4.
void interrupt ( int i, int CR1 ) {mem [CURRENT..CURRENT+6] =
(PC, R0, R1, TIMER, BASE, LIMIT, PSW);PSW.MASK = true; PSW.USER_MODE = false;R1 = CR1; PC = i; BASE = 0; LIMIT = 9999999;
}while ( true ) {
if ( "ulkoinen keskeytys tulossa" && !PSW.MASK )interrupt ( 0, "laitenumero");
TIMER = TIMER-1; if ( PC > LIMIT ) interrupt (1, invalid_address );INSTR = mem[BASE+PC];PC = PC+1;switch ( INSTR.OPCODE ) {
// tässä kuvaamattomia käskyjäcase ST1:
if ( INSTR.ADDR > LIMIT )interrupt (1, invalid_address);
elsemem[base+INSTR.ADDR] = R1;
break;case SVC: interrupt (2, INSTR.ADDR);
break;case RETI:
(PC, R0, R1, TIMER, BASE, LIMIT, PSW) = mem [CURRENT..CURRENT+6];
break;case SET_CURRENT:
if ( PSW.USER_MODE )interrupt (1, privileged_instruction);
elseCURRENT = mem[INSTR.ADDR];
break;}
}
Kuva 1.10.
keskeytys
I/O-keskeytys virheet SVC
keskeytyksen käsittely
valitse seuraavaksi suoritettava prosessi
SET_CURRENT
RETI
Kuva 1.11.
0:
1:
2:
current A:
base A:
A:n ympäristö
IO_INT:
current B: B:n ympäristö
limit A:
base B:
limit B:
vuorontaja:
1.
2.
3.
4.
Ohjelma A
JMP IO_INT
JMP error
JMP SVC_INT
…
switch ( r1 ) {
…
case READER:
kesk.käsittely
RETI
JMP vuorontaja
valitse prosessi
SET_CURRENT
…
Ohjelma B
Kuva 1.12.
tiedostojärjestelmä
muistinhallinta
ydin
swapper
sovellukset
komentotulkki
spooler
eräajoskeduleri
verkko-ohjelmistot
Kuva 2.1
RUN READY
WAIT
Vuorontaja
Odotus päättyyProsessi odottaaUusi prosessi
Prosessi poistuu
Kuva 2.2
RUN READY
WAIT
Vuorontaja
Odotus päättyy
Prosessi odottaa
SWAPPEDSWAPPED
Heittovaihtaja
Heittovaihtaja
WAIT READY
Uusi prosessi
Prosessipoistuu
Kuva 2.3
Pros. 1
Pros. 2 Pros. 3 Pros. 4
Wait-tilaan
Run-tilassa
Wait-tilasta
Kuva 2.4
Pros. 1
Pros. 2
Pros. 3
Pros. 4
Wait-tilaan
Run-tilassa Wait-tilasta
Nousevaprioriteetti
prioriteetin mukaiseenpaikkaan
Kuva 2.5
Pros. 1
Pros. 2
Pros. 3
Pros. 4
Wait-tilaan
Run-tilassa Wait-tilasta (ehkä muuttuneen)
Nousevaprioriteetti
prioriteetin mukaiseenpaikkaan
Prosessienjärjestys voivaihdella:prioriteettivaihtuu
Kuva 2.6
Pros. 1
Pros. 2 Pros. 3 Pros. 4
Wait-tilaan
Run-tilassa
Wait-tilasta
Aikaviipale loppui
Kuva 2.7
Työ 1
Työ 2
Työ 3
Työ 4
ValmistuuAjossa
Jonoon oletetun
Nousevaprioriteetti
keston mukaiseenpaikkaan
(tässä vain yksi)
Kuva 2.8
keskeytysA:
FLIH
keskeytysB:
JMP vuorontaja …RETI
FLIH
keskeytyksenkäsittely
RETI
CURRENTCURRENT
A A
B
Ympäristöpino:
Kuva 2.9
SVC SLEEP
FLIH
SLEEP:
SVC wait_event
FLIH
wait_event:
SVC vuorontajaRETI
JMP vuorontaja
vuorontaja:
RETI
FLIH
vuorontaja:
RETI
::
::
Kuva 2.10
struct PCB {int process_id; // prosessin identiteetti
enum { FREE, READY, RUN, WAIT } state;int uid; // omistajaint euid; // tehollinen omistajaint priority, native_priority; // käyttö- ja perusprioriteettiint event_number; // odotettavan tapahtuman numeroint signal_number; // tulleen signaalin numerovoid (*signals) () [NUM_SIGNALS]; // signaalinkäsittelijätbool timer_expired; // laukesiko ajastus?address saved_current; // ympäristöpinon osoitefile_descriptor files [NUM_FILES]; // käsiteltävät tiedostotint cpu_usage; // suorittimen käyttö viime sekunnin aikana// Lisäksi vielä tietoja muistinhallintaa varten sekä// laskutustietoja ja statistiikkaa, esimerkiksi// läsnäolokeskeytysten lukumäärä (tarkemmin luvussa ).
};
Wait_event
void wait_event (int e_number, int pri) {// Päivitetään event_number-kenttä prosessin prosessielementissä:
pr_table[running].event_number = e_number;pr_table[running].state = WAIT;
// Prosessi tilaan WAIT
pr_table[running].priority = pri;// Prioriteetti
odotuksen päätyttyägoto vuorontaja ;
// jatketaan vuorontajaan}
Event
void event (int e_number) {int i;
for ( i = 0; i < P_NUM; i++ ) {// käydään läpi kaikki prosessitaulun prosessielementit i:if (pr_table[i].state == WAIT && pr_table[i].event_number== e_number) {
pr_table[i].event_number = 0;pr_table[i].state = READY;
}}
}
Algoritmi 2.1
void Dispatcher {// Estetään keskeytyksetasm(IOF); // tarkoittaa, että suoritamme konekäskyn IOF// Passivoidaan suorituksessa ollut prosessi:CURRENT = CURRENT - 6;pr_table[running].saved_current = CURRENT;if ( pr_table[running].state == RUN )
pr_table[running].state = READY;// Jos ollaan palaamassa sovellukseen, palautetaan kentän// PRIORITY arvoksi NATIVE_PRIORITY eliif ( "ympäristöpinossa vain yksi ympäristö" )
pr_table[running].priority = pr_table[running].native_priority;/*Etsitään prosessitaulusta prosessi, joka on tilassa READY, ja jonka prioriteetti on suurin ja asetetaan running osoittamaan tähän prosessielementtiin (huomaa, että pieni luku tarkoittaa suurta prioriteettia ja että taustaprosessin olemassaolo takaa, että ainakin yksi suorituskelpoinen prosessi löytyy aina).
*/int i;for ( i = 0; pr_state[i] != READY; i++ ) ; // huomaa: tyhjä runkorunning = i;// etsittiin ensimmäinen READY-tilan prosessifor ( ; i != LAST_PROCESS; i++) {
if ( pr_table[i].state == READY &&pr_table[i].priority < pr_table[running].priority ) running = i;
} // käytiin läpi loputkin ja näistä suuriprioriteettisin talteenpr_table[running].state = RUN;// CURRENT-rekisteri asetetaan osoittamaan uuteen ympäristöön eliCURRENT = pr_table[running].saved_current;if ( pr_table[running].signal_number != 0 && "palaamassa sovellukseen" )
// tämä toiminto selviää vasta hieman myöhemmin …else
asm(RETI);
sivu 73
struct TIMER_QUEUE {PCB* pcb_ptr; // ajastinta odottavan prosessin prosessielementti
int time; // kellonaika, jolloin ajastin laukeaaTIMER_QUEUE* next;
};Alarm-rutiini laskee tapahtuman tapahtuma-ajan clock-muuttujan avulla:
time = clock + "halutun ajastuksen pituus"
Kellokeskeytyksen käsittely tapahtuu nyt pääpiirteissään seuraavasti:
clock = clock+1;// Poista ajastinjonon alusta kaikki elementit joille time<clock.for ( p = ajastinjono; p != 0; p = p->next ) {
if ( p->time <= clock ) {if ( p->pcb_ptr->status == WAIT )
p->pcb_ptr->status = READY;p->pcb_ptr->timer_expired = true;
} elsebreak; // else-osa toimii, jos ajat järjestyksessä
}
Kuva 3.1
free_bufs
free_bufs
free_bufs
k1
k2k1
k1
k2
k1
Sivu 92
Esimerkkikäyttöjärjestelmässä kriittiseen alueeseen voitaisiin liittää muuttujat lock_bit ja waiting seuraavasti:
L: if ( lock_bit == 1 ) {waiting = true;
wait_event (&waiting);goto L;
}lock_bit = 1;
… kriittisen alueen käskyt …lock_bit = 0;if ( waiting ) {
waiting = false;event (&waiting);
}
Algoritmi 3.1
class semaphore {void P ();
void V ();semaphore (int);
privateint val;PCB* link;
}semaphore :: P (){
val = val-1;if ( val < 0 ) {
linkitä prosessin PCB LINK-ketjun loppuun;Aseta prosessin tilaksi WAIT;Siirry vuorontajaan;
}}semaphore :: V (){
val = val+1;if ( val <= 0 ) {
Linkitä jonon ensimmäinen prosessielementti poissemaforijonosta ja siirrä se tilaan READY;Jos herätetyn prosessin prioriteetti on herättävän prosessinprioriteettia suurempi, siirry vuorontajaan;
}}semaphore :: semaphore (int initial), val (initial), link (NULL){}
Algoritmi 3.2
lukko:.word 0
lock:mov #1,%1 // Varausvakio 1 rekisteriin yksil1:swap %1,lukko// Vaihdetaan varattutieto lukkoonbrpos l1 // Mikäli lukossa oli 1, yritetään uudestaan
ret // Lukitus onnistuiunlock:
mov #0,lukkoret
Algoritmi 3.3
lukko:.word 0
lock:btset lukko,lock // Jos bitti asetettu, testaa uudelleenret
// Lukitus onnistuiunlock:
bclr lukko // Nollaa bitti, bit clearret
Algoritmi 3.4
volatile boolean flag[2] = { false, false };volatile int turn;void Dekker (int i, j){
flag[i] = true; // Haluan alueellewhile (flag[j]) // Mikäli toinenkin haluaa, jäädään silmukkaan
if (turn == j) { // Itse asiassa on toisen vuoroflag[i] = false; // joten päästetään toinen sisään,while (turn == j); // odotetaan sen poistumistaflag[i] = true; // ja yritetään taas
}}
void unlock(void){
turn = j; // Tällä annetaan toiselle prosessille etuoikeusflag[i] = false; // Vapautetaan alue}
Algoritmi 3.5
volatile enum {idle, want_in, in_cs} flags [n];volatile int turn;void Eisenberg_McGuire (int i){
int j;do {
flag[i] = want_in;j = turn;// tällä on etuoikeuswhile (j != i)// odotetaan etuoikeutetut pois
if (flag[j] != idle) j = turn;// jäit toiseksi, aloita alusta
else j = (j+1) % n; // tämä ei ole kiinnostunut, ohitaflag[i] = in_cs;
// luulen päässeeni läpi// Käydään kaikki prosessit läpi. Jos kukaan muu ei ole// in_cs-tilassa, silmukasta poistuttaessa j == n j = 0;while ((j < n) && ( j == i || flag[j] != in_cs)) j += 1;// Lukitus onnistui, mikäli i == n ja turn-muuttujan// osoittama prosessi ei ole kiinnostunut
} while ((j < n) || (turn != i && flag[turn] != idle));turn = i; // Varmistetaan varaus}
void unlock(void){
j = (turn+1) % n; // Etuoikeuden hakeminen: seuraava prosessiwhile (flag[j] == idle) {
j = (j+1) % n; // Jos ei kiinnostunut, hae seuraava}turn = j;flag[i] = idle; // Sijoitus täällä, jotta edellinen silmukka päättyy aina
}
Algoritmi 3.6
volatile boolean flag[2] = { false, false };volatile int turn;void Patterson (i, j){
flags[i ] = true;turn = j ; // Anna vuoro pois!while ((flags[j ]) && (turn != i )) {// Odota niin kauan, kunnes toinen luovuttaa vuoron}
}void unlock(void){
flags[i ] = false;}
Kuva 3.2
puskuri
size
K1
K2
T1
T2
out_index in_index
Algoritmi 3.7
typedef item_type …// käsiteltävän alkion tyyppi
const int size = 100;// puskurin kokoitem_type buf [size];
// puskuriint in_index(0), out_index(0);
// puskuriosoittimiasemaphore mutex1(1), mutex2(1);
// semaforit poissulkemiseensemaphore free(size);
// vapaiden alkioiden semaforisemaphore full(0);
// täysien alkioiden semaforiprocess Tuottaja (i, j){
while ( true ) { // ikuinen silmukka… tuota alkio item …P(free); // varmista, että vapaita puskureita onP(mutex1);buf[in_index] = item;in_index = (in_index+1) % size; // % on siis jakojäännösV(mutex1);V(full);
}}
process Kuluttaja{
while ( true ) { P(full); // varmista, että täysiä puskureita onP(mutex2);item = buf[out_index];out_index = (out_index+1) % size;V(mutex2);V(free);… kuluta alkio item …
}}
Kuva 3.3
K2
K1
Kn
L1
L2
Ln
…
…
TietorakenneK2
Algoritmi 3.8int read_count = 0;
// aktiivisten lukijoiden määräsemaphore mutex(1);
// lukijalaskurin poissulkemiseensemaphore write_mutex(1);
// kirjoittaijen poissulkemiseeniprocess Lukija{
while ( true ) {// ikuinen silmukka// tekee jotain, jonka jälkeen haluaa lukea…P(mutex); // varmista, että vapaita puskureita on
read_count = read_count+1; // lukijoita yksi enemmän
if ( read_count == 1 ) {// ensimmäinen lukija?P(write_mutex);
// käyttäydy kuin kirjoittaja}
V(mutex);// Varsinainen lukeminen tapahtuu tässä
P(mutex);read_count = read_count+1;
// lukijoita yksi vähemmänif ( read_count == 0 ) {// viimeinen lukija?
V(write_mutex); // käyttäydy kuin kirjoittaja}
V(mutex);}
}process Kirjoittaja{
while ( true ) { //… miettii mitä pitäisi muuttaa …P(write_mutex);
// Kirjoittaa tässä kohtaaV(write_mutex);
}}
Kuva 3.4
0
1
2
3
0 1
2
3
Kuva 3.5 ja 3.6. puuttuvat
Kuva 3.7
mbox
P1
P2
P3
P4
P5
Kuva 3.8
P1
P2
P3
P4
Q1
Q2
Q3
Kuva 3.9
P1 P2 P3
Algoritmi 3.9monitor Philosophers {
const last_phil = 4;enum { thinking, hungry, eating } state[last_phil];condition self[last_phil];void test (int k){
if (state[(k-1) % last_phil] != eating &&-- huom: -1 mod 4 = 3state[k] = hungry && state[(k+1) % last_phil] != eating) {state[k] = eating;signal(self[k]);
}}void pick_up(int i){
state[i] := hungry;test(i);if (state[i] != eating) {
await(self[i]);}
}void put_down(int i){
state[i] := thinking;test[(i-1) % last_phil];test[(i+1) % last_phil];
}}
Algoritmi 3.10
type item_type is …-- käsiteltävän alkion tyyppi
task producer;task consumer;task buffer is
-- määritellään puskurisäikeen "jonot" eli portitentry put(item: in item_type);
-- tähän porttiin lähetetään pyyntöjä-- alkioiden item viemiseksi puskuriin
entry get(item: out item_type);-- alkioiden noutopyyntöjen portti
end buffer;
Algoritmi 3.11
task body producer islocal_item: item_type;begin
loop-- … tuota local_item …buffer.put(item); -- item-sanoma porttiin put
end loop;end producer;
task body consumer islocal_item: item_type;begin
loopbuffer.get(local_item);-- odota kunnes buffer antaa alkion… kuluta local_item …
end loop;end consumer;
Algoritmi 3.12
task body buffer is -- määritellään puskurisäikeen toimintasize: constant :=100; -- puskurin kokobuf: array(1.. size) of item_type; -- puskuricount: integer range 0..size := 0; -- alkioiden lkm puskurissain_index,out_index:integer range 1..size := 1;-- puskuriosoittimia
beginloop
select -- odota sanomia portteihinwhen count < size =>
accept put(item: in item_type) dobuf(in_index):=item;
end;in_index:=in_index mod size+1;count:=count+1;
orwhen count>0 =>
accept get(item: out item_type) doitem:=buf(out_index);
end;out_index:=out_index mod size+1;count:=count-1;
or terminate;
end select;end loop;
end buffer;
Kuva 4.1
käyttöjärjestelmä sovellus1 sovellus2 sovellus3
käyttöjärjestelmä sovellus1 sovellus2sovellus3
OS/MFT
OS/MVT
Kuva 4.2
3B7A00F:
03E:
02D:
01C:
0FB:
0EA:
159:
0D8:
0C7:
106:
115:
144:
043:
0B2:
091:
080:
Sivurekisterit
Virtuaaliosoite
32A5
15:
14:
13:12:
11:
10:
9:
8:
7:
6:
5:
4:
3:2:
1:
0:
F:
E:
D:
C:
B:
A:
Virtuaaliosoite
Muistiavaruus
&
&
0E3B7
1132A
Kuva 4.3
7F00071F:
1E:
002BB:
A:
9:
8:
002A7:
6:
5:
001B4:
3:
003F2:
1:
0:
Sivutaulu
Virtuaaliosoite
&
::
002B000B
003F0002
002A0007
001B0004
002A7F
TLB
avain tieto
000B
Kuva 4.4
Pääohjelma
T1 T2 T3 T4
A1
A2
Kuva 4.5
Keskusmuisti
Pääohj.T1
T2
T3
T4
A1
A2
Kuva 4.6
koodi "heap" pino
Kuva 4.7
sivutaulun osoite
siirtymäsegmenttitaulun indeksi sivutaulun indeksi
Virtuaaliosoite
Segmenttitaulu
sivutilan numero
& &
Sivutaulu
muistiosoite
Kuva 4.8
VPAa
Virtuaaliosoite
sivunnumero
hajautinfunktio
siirtymä
VPAx •
VPAa nili:
sivutilataulu
hajautintaulu
Muistiosoite
i
Kuva 4.9
sivutaulu a
sivutaulu b
1
1
1
1
1
1
Kuva 4.10
suoritusaika (miljoonaa muistiviitettä)
os
oit
ea
va
ru
us
(k
ym
me
ni
ä K
-t
av
uj
a
a’
6
4 b
itti
ä)
6
5
4
3
2
1
0
1 2 3
Kuva 4.11
elinikä
polvipiste
b) muistin määrä
suoritusaika
a) muistin määrä
Kuva 4.12
suoritusteho
moniajoaste
ruuhkautuminen
Kuva 4.13
1
1
0
0
1
0
1
1
…
victim
Kuva 4.14
muistin käyttö
suoritusaika
Ohjelman tarvitsema määrä
partition koko
Kuva 4.15
muistin käyttö
suoritusaika
Ohjelman tarvitsema määrä
käyttöjoukon koko
Kuva 4.16 Sivutaulun alkion rakenne.
P: läsnäolobitti U: viitebittiM: muutosbitti R: kirjoitussuojausbittiF: F=1, niin PFI on sivutilan numero
F=0 ja PFI > 0, niin PFI on levyosoiteF=0 ja PFI = 0, niin sivutila nollataan varattaessa (alustamaton datasivu)
P U M R F PFI
Kuva 4.17 Sivutilataulun alkion rakenne.
DADDR: levyosoite, silloin kun levy on keskusmuistissa.PTE: osoitin sivutaulun alkioon (nolla, jos vastaava alkiota ei ole).PROS: sivutaulun omistavan prosessin indeksiFL, BL: ketjutettu lista (kaksisuuntainen, FL eteen ja BL taaksepäin)STATE: sivun mahdolliset tilat:
valid: sivu kuuluu jonkin prosessin käyttöjoukkoon,reading: sivua luetaan parhaillaan,writing: sivua kirjoitetaan parhaillaaan,inmfpl: sivu on MFP-listassa jainfpl: sivu on FP-listassa.
AGE: aika, jonka sivu on ollut viittaamatta.L: lukitusbitti.
DADDR PTE PROS FL, BL STATE AGE L
Kuva 4.18
non-existent
present,unmodified
present,modified
free,
modified
free,
unmodified
on
disk
keskeytys
keskeytys
keskeytys keskeytys
kirjoitus
keskusmuistiin
kirjoitus
levylle
poisto-algoritmi
poisto-algoritmi
sivutilan
varaus
Kuva 4.19 Osoiteavaruuden jako Windows NT:ssä.
P0: sovelluksen koodialue, 00000000 … 3FFFFFFFP1: sovelluksen data-alue, 40000000 … 7FFFFFFFP2: suoraan osoitettava kj:n alue, 80000000 … BFFFFFFFP3: käyttöjärjestelmä, C0000000 … 7FFFFFFF
P0 P1 P2 P3
Kuva 5.1
Pinta
UraSektori
Sylinteri
Kuva 5.2
Keskusyksikkö
Laiteohjain1Muisti Laiteohjain2
Laite5
Laite4
Laite3
Laite2
Laite1Laite
väylä
Laite
väylä
Sisä inen väylä
Kuva 5.3
Laite4
Laite3
Laite2
Laite1
Laite7
Laite6
Laite5
Muisti
Laiteohjain2 Laiteohjain3Laiteohjain1 Laiteohjain4
I/O-suoritin1 I/O-suoritin2
Keskusyksikkö tai -yksiköt
Laiteohjain1
Laite1
Laite4
Laite
väylä
La
iteväylä
Laite
väylä
Laite
väylä
S isäinen väyläNopea muistiväylä
I/O-suoritin 1:n väylä I/O-suoritin 2:n väylä
Kuva 5.4
Tiedostojärjestelmä
Prosessi
käyttäjän tila
ytimen tila
työjono
Laiteajuri
kutsuosa keskeytysosa
laite
1
2
34
5
Kuva 5.5
/
usr bin
etc bin
home
ijh hmj
kirja
kj
luku5
……
…
var
spool
kalvot
Kuva 5.6
/
usr bin
etc bin
home
ijh hmj
kirja
kj
luku5
……
…
var
spool
kalvot
Kuva 5.7
laitekuvaaja i
FREE_BUFS
•
•
device = i
busy = true
read
block num
:
•
nil
device = i
busy = true
write
block num
:
•
•
device = i
busy = false
-
block num
:
•
•
device = i
busy = false
-
block num
:
•
•
device = k
busy = false
-
block num
:
nil
•
device = i
busy = false
-
block num
:
työjono
puskurijono
nil
:
Sivu 199, tunnustietue
•laitteen numero *•lukitusbitti *
•käyttäjälaskuri (montako samanaikaista käyttäjää) *•tunnustietueen indeksi levyn tunnustietuealueella *•hakemiston tunnustietueen korvaava tunnustietue, jos toinen levy on kiinnitetty mount-komennolla tähän hakemistoon*•tiedoston tyyppi (hakemisto vai tavallinen tiedosto)•tiedoston omistajan käyttäjätunnus•käyttöoikeustietoja (read-, write- ja execute-oikeudet tiedoston omistajalle sekä muille ja SUID-bitti)•tiedoston koko•viitelaskuri (monestako hakemistosta viite tähän tiedostoon)•viimeinen muutospäivä (ja ehkä muitakin aikaleimoja) sekä•tiedoston tietojen sijainti levyllä (12 lohkon numeroa á 32 bittiä, lohkon koko 4096 tavua):
•10 ensimmäistä alkiota sisältävät 10 ensimmäisen lohkon numerot (siis tiedoston ensimmäiset 40 kilotavua)•11. alkio osoittaa lohkoon, joka sisältää korkeintaan 1024 seuraavan lohkon numerot (tiedoston seuraavat 4 megatavua)•12. alkio osoittaa korkeintaan 1024 lohkoon, jotka edelleen kukin sisältävät korkeintaan 1024 lohkon osoitetta (232 tavua).
* Ei esiinny levyllä olevassa tunnustietueessa.
Kuva 5.8
FP
INDX 1023:n
lohkon
osoitteet
vapaan
1023:n
lohkon
osoitteet
vapaan
vapaiden
lohkojen
osoitteita
Kuva 5.9
1.
2.
10.
:
tunnustietue
11.
1034.
1035.
2058.
iso
tosi iso
Epäsuorat lohkot
1
2
:
10
11
12
::
:
:
Suorat lohkot Toisen tason epäsuorat lohkot
Kuva 5.10
tiedostotauluja (PCB)
mode fptr noderead 10write 0
tunnustietue:
juurihakemistontunnustietue
tunnustietuetaulujärjestelmän tiedostotaulu
laitekuvaustaulu
… 0-lohkon kopio
Kuva 5.11
home i
Juurihakemisto (root, /)
i:
k:
j:
pekka j
home
tietotunnustietuetaulu
tieto k
pekka
Kuva 5.12
Tunnustietuetaulu
a) ei mount-komentoa
Viittaus hakemiston
Tunnustietuetaulu
b) mount-komento annettu
Viittaus toisen levyn
juurihakemiston
Viittaushakemiston
tunnustietueeseen
lohkoihin
Viittaushakemiston
tunnustietueeseen
lohkoihin
Viittauksen ohjaus eteenpäin
Kuva 5.13
Pyynnön esittänyt prosessi
I/O-Manager
Tiedostojärjestelmä-ajuri
Laiteajuri
Laite
Kuva 5.14 Tason RAID 5 -järjestelmä viidellä levyllä.
Tiedot on talletettu viidelle levylle neljän lohkon juovina. Viides, varjostettu lohkoon pariteettilohko.
1 2 3 4 5
Kuva 6.1Verkkoarkkitehtuuriin perustuva sovellus.
verkko käyttöjärjestelmä
Kuva 6.2 Hajautettu tietokantajärjestelmä.
tietokanta
verkko käyttöjärjestelmä
Kuva 6.3 Hajautettu tiedostojärjestelmä.
tiedostojärj.
verkko
muu
käyttöjärjestelmä
Kuva 6.4 Hajautettu käyttöjärjestelmä.
käyttöjärjestelmä
verkko
Kuva 6.5 Esimerkki seittisovelluksen rakenteesta.
käyttöjärjestelmä
verkko
Java-virtuaalikone
J2EE-sovelluspalvelin
käyttöliittymälogiikka
käyttöjärjestelmä
verkko
tietokanta-palvelin(servletit, JSP-sivut)
asiakas-käyttöliittymät HTTP
JDBCja -sovellukset
