Kuva 1.1. Hierarkkinen kone.

Esitys aiheesta: "Kuva 1.1. Hierarkkinen kone."— Esityksen transkriptio:

1

2 Kuva 1.1. Hierarkkinen kone.

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

4 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; } }

5 Kuva 1.3. Työ reikäkorteilla.

6 Kuva 1.4.

7 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; } }

8 Kuva 1.5.

9 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); }

10 Kuva 1.6.

11 Kuva 1.7.

12 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; } }

13 Kuva 1.8.

14 Kuva 1.9.

15 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 = ; } 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; } }

16 Kuva 1.10.

17 Kuva 1.11.

18 Kuva 1.12.

19 Kuva 2.1

20 Kuva 2.2

21 Kuva 2.3

22 Kuva 2.4

23 Kuva 2.5

24 Kuva 2.6

25 Kuva 2.7

26 Kuva 2.8

27 Kuva 2.9

28 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 ). };

29 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 }

30 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; } } }

31 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);

32 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ä }

33 Kuva 3.1

34 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); }

35 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) {}

36 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

37 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

38 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 }

39 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 }

40 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; }

41 Kuva 3.2

42 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 … } }

43 Kuva 3.3

44 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); } }

45 Kuva 3.4

46 Kuva 3.5 ja 3.6. puuttuvat

47 Kuva 3.7

48 Kuva 3.8

49 Kuva 3.9

50 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]; } }

51 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;

52 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;

53 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;

54 Kuva 4.1

55 Kuva 4.2

56 Kuva 4.3

57 Kuva 4.4

58 Kuva 4.5

59 Kuva 4.6

60 Kuva 4.7

61 Kuva 4.8

62 Kuva 4.9

63 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

64 Kuva 4.11

65 Kuva 4.12

66 Kuva 4.13

67 Kuva 4.14

68 Kuva 4.15

69 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

70 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

71 Kuva 4.18

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

73 Kuva 5.1

74 Kuva 5.2

75 Kuva 5.3

76 Kuva 5.4

77 Kuva 5.5

78 Kuva 5.6

79 Kuva 5.7

80 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.

81 Kuva 5.8

82 Kuva 5.9

83 Kuva 5.10

84 Kuva 5.11

85 Kuva 5.12

86 Kuva 5.13

87 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

88 Kuva 6.1Verkkoarkkitehtuuriin perustuva sovellus.

89 Kuva 6.2 Hajautettu tietokantajärjestelmä.

90 Kuva 6.3 Hajautettu tiedostojärjestelmä.

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

92 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