Kuva 1.1. Hierarkkinen kone.

Slides:



Advertisements
Samankaltaiset esitykset
18. Abstraktit tietotyypit
Advertisements

Tietokonetekniikka 4 Tieto ja tiedon talletus
Tietokoneen käyttöjärjestelmä
15. Loogiset operaatiot.
Olio-ohjelmoinnin perusteet luento 3: Muuttujista ja funktioista Sami Jantunen LTY/Tietotekniikan osasto.
© Hannu Laine 1 Tietorakenteet ja algoritmit Funktio-osoittimet Funktio-osoittimen ja taulukko-osoittimen vertailu Funktio-osoittimen käyttötapoja.
PROSESSIT Tehtäviä: Limittää usean prosessin suoritus, jotta resurssien käyttö olisi tehokasta, mutta samalla taata, että kaikki prosessit etenevät mielekästä.
vuorovaikutteiset www-sivut 1.Asiakas-palvelinmalli kuvana Request Response request.asp response.asp.
2.8.3 Abstraktit tietotyypit
Taulukot Jukka Juslin © Jukka Juslin 2006.
Taulukot: Array Taulukko Javassa pitää aina perustaa (new)
22. Taulukot.
Sovellusohjelman suunnittelu & toteutus
C-ohjelmointi, kevät 2006 Taulukot Binääritiedostot Luento
Windows NT Mika Purmonen
@ Leena Lahtinen OHJELMAN OSITTAMINEN LUOKKA ATTRIBUUTIT METODIT.
Ohjelmoinnin tekniikkaa Sisällys for -lause lyhemmin. Vaihtoehtoisia merkintöjä aritmeettisille lauseille. Useiden muuttujien esittely.
Muistinhallinta. 2 Teknisiä kehitysaskelia §Muisti- ja osoiteavaruuden erottaminen toisistaan l virtuaaliosoitteiden avulla muistin koko voi olla suurempi.
Pseudokoodi Tietokoneohjelmien perusidea:
13. Hyvä ohjelmointitapa (osa 1)
2 - 1 Rio syksy 2004 OSA I: Yhteisten muuttujien käyttö Prosessit samassa koneessa.
1 Kertaus koetta varten oleellisista asioista Jukka Juslin.
TIEP114 Tietokoneen rakenne ja arkkitehtuuri, 3 op
Map-luokka Mikä Map on? Mapin esittely ja luonti Map-luokan metodeja Mappiin lisääminen Mapin läpikäynti Mapista poistaminen 1.
Sovellustason protokollat. Sovellusohjelman rakenne pääohjelma käyttäjän kanssa kommunikoivat aliohjelmat (modulit) tiedostojen käsittelypakkaus tietoliikennettä.
ict1td002 - Copyright Raine Kauppinen 1 Alkuarvot ja tyyppimuunnokset (1/5)  Aiemmin olemme jo antaneet muuttujille alkuarvoja, esimerkiksi: int.
Visual Basic -ohjelmointi
1 9. Muistinhallinta l Moniajojärjestelmässä keskusmuisti on jaettu usean prosessin kesken l => ohjelman paikka muistissa ei ole kiinteä, vaan koodi on.
Metodit – Arvotyyppi Ellei metodi palauta arvoa, sen arvotyyppi on void Tällöin ”return;”-lauseke ei ole metodissa pakollinen, vaikka sen käyttö on sallittua.
11. Javan toistorakenteet
SQL Standardoitu kieli, jonka avulla voidaan
Kuinka niitä käsitellään
Muuttujat ja vakiottMyn1 Muuttujat ja vakiot PHP-kielen syntaksi on lainattu suurimmaksi osaksi C- kielestä. PHP on erityisesti HTML-dokumenttien sisään.
Tietotekniikan peruskäsitteet
4. Attribuutit 4.1. Sisällys Yleistä attribuuteista. Näkyvyys luokan sisällä ja ulkopuolelta. Attribuuttien arvojen käsittely aksessoreilla. 4.2.
@ Leena Lahtinen OHJELMAN OSITTAMINEN LUOKKA ATTRIBUUTIT METODIT.
Lomakkeet © Reiska, Lomakkeet Varsinkin Web-sovelluksia ajetaan täyttämällä sivulla lomake ja lähettämällä tiedot palvelimella olevan Web-sovelluksen.
@ Leena Lahtinen Toistorakenne Ohjelmassa toistetaan tiettyjä toimenpiteitä monta kertaa peräkkäin Toisto noudattaa sille kuuluvia tarkkoja standardoituja.
@ Leena Lahtinen TIETOKONEOHJELMAN RAKENNE OHJELMALLA ON KAKSI OSAA:  MÄÄRITYSOSA TIETOJEN KUVAUKSIA VARTEN  SUORITUSOSA TIETOJEN KÄSITTELYÄ.
Rinnakkaisuus Järjestelmässä, jossa voi olla useita prosesseja rinnakkain suorituksessa voi tulla tilanteita, joissa prosessien suoritusta täytyy kontrolloida.
Tiedostojen käsittely
Olioiden taulukointi Perustaulukon käyttö Luokan ilmentymät voidaan tallettaa taulukkoon samoin kuin muuttujat Esimerkki talletetaan taulukkoon opintojaksojen.
Antti-Jussi Lakanen Nuorten peliohjelmointi 2009 / Jyväskylän yliopisto.
Kontrollirakenteet laajemmin
Visual Basic -ohjelmointi
Java - Tietokanta. JDBC=Java database connectivity  ODBC:n kaltainen ohjelmointiliittymä SQL- tietokantoihin  Koostuu Java-kehitysympäristön (esim.
1 Rio s05 / Liisa Marttinen Kertaus: Semaforit Semaforin operaatiot: sem s = n; # semaforin alkuarvo P(s); # jos s
Javascript 2: Ohjelmointikielen ominaisuudet Jaana Holvikivi Metropolia.
1 Rio / Auvo Häkkinen Kertaus: Semaforit Semaforin operaatiot: sem s = n; # semaforin alkuarvo P(s); # jos s
1..toistolauseet While Wend For Each In [Exit For] Next.
Ohjausrakenteet Määräävät ohjelmakoodin suoritusjärjestyksen Ehtolause if – else on muotoa if (lauseke) lause1 else lause2 Jos lauseke on tosi, niin suoritetaan.
TEKNIIKAN JA TALOUDEN YLIOPISTO Luku 23 – Signal Driven IO  Periaate  Esimerkki.
Ohjelma Mikro-ohjelmointi Symbolinen konekieli Osoitustavat.
Windows 2000 Jukka Stranden Marko Suhonen Käyttöjärjestelmät Seminaari 2006.
Hajoita ja hallitse (divide and conquer) Pikalajittele n-alkioinen taulukko 1. Divide: Jaetaan taulukko kahdeksi alitaulukoksi tukialkion (pivot) x suhteen:
TIEP114 Tietokoneen rakenne ja arkkitehtuuri, 3 op Assembly ja konekieli.
TIEP114 Tietokoneen rakenne ja arkkitehtuuri, 3 op
Yhden bitin asettaminen Javalla
13. Loogiset operaatiot.
Toisto Toistolausekkeet for, while(ehto){…} ja do {…} while(ehto)
Kuinka niitä käsitellään
11. Javan valintarakenteet
ioctl #include <sys/ioctl.h> int ioctl(int d, int request, ...);
10. Siirräntäjärjestelmät
8. Ohjelman toteutus järjestelmässä
Kontrollirakenteet laajemmin
10. Siirräntäjärjestelmät
4. Ohjelmointi konekielellä (TTK-91 ja Titokone)
10. Siirräntäjärjestelmät
10. Siirräntäjärjestelmät
Esityksen transkriptio:

Kuva 1.1. Hierarkkinen kone.

Käskyrekisteri INSTR: yleisrekisterit R0 ja R1 Kuva 1.2. OPCODE ADDRESS Rekisterit: Käskyrekisteri INSTR: yleisrekisterit R0 ja R1 ohjelmalaskuri PC (program counter)

Algoritmi 1.1. while ( true ) { INSTR = mem[PC]; // Hae käsky PC = PC+1; // Päivitä ohjelmalaskuria switch ( 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; } }

Kuva 1.3. Työ reikäkorteilla.

Kuva 1.4.

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.

sivu 22. while ( CR_STATUS == BUSY ) ; // tyhjä silmukka if ( "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.

Kuva 1.7.

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.

Kuva 1.9.

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); else mem[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); else CURRENT = mem[INSTR.ADDR]; break; } }

Kuva 1.10.

Kuva 1.11.

Kuva 1.12.

Kuva 2.1

Kuva 2.2

Kuva 2.3

Kuva 2.4

Kuva 2.5

Kuva 2.6

Kuva 2.7

Kuva 2.8

Kuva 2.9

Kuva 2.10 struct PCB { int process_id; // prosessin identiteetti enum { FREE, READY, RUN, WAIT } state; int uid; // omistaja int euid; // tehollinen omistaja int priority, native_priority; // käyttö- ja perusprioriteetti int event_number; // odotettavan tapahtuman numero int signal_number; // tulleen signaalin numero void (*signals) () [NUM_SIGNALS]; // signaalinkäsittelijät bool timer_expired; // laukesiko ajastus? address saved_current; // ympäristöpinon osoite file_descriptor files [NUM_FILES]; // käsiteltävät tiedostot int 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 keskeytykset asm(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 eli if ( "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ä runko running = i; // etsittiin ensimmäinen READY-tilan prosessi for ( ; 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 talteen pr_table[running].state = RUN; // CURRENT-rekisteri asetetaan osoittamaan uuteen ympäristöön eli CURRENT = 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 laukeaa TIMER_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; } else break; // else-osa toimii, jos ajat järjestyksessä }

Kuva 3.1

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); private int 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 pois semaforijonosta ja siirrä se tilaan READY; Jos herätetyn prosessin prioriteetti on herättävän prosessin prioriteettia suurempi, siirry vuorontajaan; } } semaphore :: semaphore (int initial), val (initial), link (NULL) {}

Algoritmi 3.2 lukko: .word 0 lock: mov #1,%1 // Varausvakio 1 rekisteriin yksi l1: swap %1,lukko// Vaihdetaan varattutieto lukkoon brpos l1 // Mikäli lukossa oli 1, yritetään uudestaan ret // Lukitus onnistui unlock: mov #0,lukko ret

Algoritmi 3.3 lukko: .word 0 lock: btset lukko,lock // Jos bitti asetettu, testaa uudelleen ret // Lukitus onnistui unlock: bclr lukko // Nollaa bitti, bit clear ret

Algoritmi 3.4 volatile boolean flag[2] = { false, false }; volatile int turn; void Dekker (int i, j) { flag[i] = true; // Haluan alueelle while (flag[j]) // Mikäli toinenkin haluaa, jäädään silmukkaan if (turn == j) { // Itse asiassa on toisen vuoro flag[i] = false; // joten päästetään toinen sisään, while (turn == j); // odotetaan sen poistumista flag[i] = true; // ja yritetään taas } } void unlock(void) { turn = j; // Tällä annetaan toiselle prosessille etuoikeus flag[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 etuoikeus while (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, ohita flag[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 prosessi while (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

Algoritmi 3.7 typedef item_type … // käsiteltävän alkion tyyppi const int size = 100; // puskurin koko item_type buf [size]; // puskuri int in_index(0), out_index(0); // puskuriosoittimia semaphore mutex1(1), mutex2(1); // semaforit poissulkemiseen semaphore free(size); // vapaiden alkioiden semafori semaphore full(0); // täysien alkioiden semafori process Tuottaja (i, j) { while ( true ) { // ikuinen silmukka … tuota alkio item … P(free); // varmista, että vapaita puskureita on P(mutex1); buf[in_index] = item; in_index = (in_index+1) % size; // % on siis jakojäännös V(mutex1); V(full); } } process Kuluttaja { while ( true ) { P(full); // varmista, että täysiä puskureita on P(mutex2); item = buf[out_index]; out_index = (out_index+1) % size; V(mutex2); V(free); … kuluta alkio item … } }

Kuva 3.3

Algoritmi 3.8 int read_count = 0; // aktiivisten lukijoiden määrä semaphore mutex(1); // lukijalaskurin poissulkemiseen semaphore write_mutex(1); // kirjoittaijen poissulkemiseeni process 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än if ( 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ä kohtaa V(write_mutex); } }

Kuva 3.4

Kuva 3.5 ja 3.6. puuttuvat

Kuva 3.7

Kuva 3.8

Kuva 3.9

Algoritmi 3.9 monitor 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 = 3 state[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 portit entry 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 is local_item: item_type; begin loop -- … tuota local_item … buffer.put(item); -- item-sanoma porttiin put end loop; end producer; task body consumer is local_item: item_type; begin loop buffer.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 toiminta size: constant :=100; -- puskurin koko buf: array(1.. size) of item_type; -- puskuri count: integer range 0..size := 0; -- alkioiden lkm puskurissa in_index,out_index:integer range 1..size := 1;-- puskuriosoittimia begin loop select -- odota sanomia portteihin when count < size => accept put(item: in item_type) do buf(in_index):=item; end; in_index:=in_index mod size+1; count:=count+1; or when count>0 => accept get(item: out item_type) do item:=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

Kuva 4.2

Kuva 4.3

Kuva 4.4

Kuva 4.5

Kuva 4.6

Kuva 4.7

Kuva 4.8

Kuva 4.9

Kuva 4.10 ) b 4 6 ’ 5 j - K ä n 3 m y k 2 ( u r 1 v a e t i s o suoritusaika (miljoonaa muistiviitettä) o s i t e a v r u ( k y m n ä K - j ’ 6 4 b ) 5 3 2 1

Kuva 4.11

Kuva 4.12

Kuva 4.13

Kuva 4.14

Kuva 4.15

Kuva 4.16 Sivutaulun alkion rakenne. P: läsnäolobitti U: viitebitti M: muutosbitti R: kirjoitussuojausbitti F: F=1, niin PFI on sivutilan numero F=0 ja PFI > 0, niin PFI on levyosoite F=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 indeksi FL, 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 ja infpl: sivu on FP-listassa. AGE: aika, jonka sivu on ollut viittaamatta. L: lukitusbitti. DADDR PTE PROS FL, BL STATE AGE L

Kuva 4.18

Kuva 4.19 Osoiteavaruuden jako Windows NT:ssä. P0: sovelluksen koodialue, 00000000 … 3FFFFFFF P1: sovelluksen data-alue, 40000000 … 7FFFFFFF P2: suoraan osoitettava kj:n alue, 80000000 … BFFFFFFF P3: käyttöjärjestelmä, C0000000 … 7FFFFFFF P0 P1 P2 P3

Kuva 5.1

Kuva 5.2

Kuva 5.3

Kuva 5.4

Kuva 5.5

Kuva 5.6

Kuva 5.7

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

Kuva 5.9

Kuva 5.10

Kuva 5.11

Kuva 5.12

Kuva 5.13

Kuva 5.14 Tason RAID 5 -järjestelmä viidellä levyllä. Tiedot on talletettu viidelle levylle neljän lohkon juovina. Viides, varjostettu lohko on pariteettilohko. 1 2 3 4 5

Kuva 6.1Verkkoarkkitehtuuriin perustuva sovellus.

Kuva 6.2 Hajautettu tietokantajärjestelmä.

Kuva 6.3 Hajautettu tiedostojärjestelmä.

Kuva 6.4 Hajautettu käyttöjärjestelmä.

Kuva 6.5 Esimerkki seittisovelluksen rakenteesta. käyttöliittymälogiikka tietokanta- (servletit, JSP-sivut) palvelin asiakas- J2EE-sovelluspalvelin käyttöliittymät HTTP ja -sovellukset Java-virtuaalikone JDBC käyttöjärjestelmä käyttöjärjestelmä verkko verkko