Systemanropp kontrollen övergår från userspace till kernelspace ca 100 i UNIX, många fler i NT

Transkript

1 Leason 1 ============================================ Vad är ett operativsystem *Det program som implmenterar allasystemanropp. *Det / de program som köri kernel-mode Datahistoria: * Mekaniska reläer, vakumtuber. Kopplingspaneler och senare hålkort, inget OS, ENIAC, BARK, BESK. * Transistorer, maiframes, batch, utskrift av resultat * Integrerade kretsar, mainframes,minidatorer, Operativsystemviktiga, OS/360, MULTICS, UNIC, multiprogrammering, timesharing. * Superdatorer,mikrodatorer (persondatorer), inbyggda system, nätverk, användarvänlighet Vad sköter ett os? *Filsystem (persistent lagring) *I/O (abstraktion) *Processer *Kommunikation *Säkerhet access Två sätt att se OS. *Abstratiktion av mjukvara från hårdvara *Resurshanterare / fördelare Architecture *Monolitish *Lagrad *Mikrokärna *Virtuell maskiner Systemanropp kontrollen övergår från userspace till kernelspace ca 100 i UNIX, många fler i NT Ett program är en följd av instruktioner, en process är ett program som kör just nu Ett entry i Processtabellen kallas Process Control Block (PCB) Schemaläggningsmål *Allmänt, fair, balans *Batch, maximera througput,minimera turnaroundm maximera cpuanvändning *Interaktiva system, minimera responstid *Realtidssystem, klara deadlines, vara förutsägbart Om man vet alla processers exectid i förväg kanman använda Shortest Job First. OM man är ute efter kortaste medelsluttiden är sjortest job first optimal Time-slicing Alla processer som är redo ligger på readylistan. När en process har använt sin cpu tid läggs den sist i listan. För att få bra prestanda krävs en bra relation mellan time-slice och tiden det tar att byta running process Alla processer har en prioritet i unix system V Processens prioritet kan ändras under exekvering.

2 Om man använder prioritering och timeslice. *En process som använder hela sin time slice otan att bli BLOCKED får lägre prioritet. *En process som ligger i readykön får suksesivt högre prio för att undvika svältning. Round Robin Shortest Process next Probabilistisk schemaläggning (lotteri) Leason 2 ============================================ Ju snabbare minne desto dyrare *Register i cpu, *cache *prim minne *elektronisk disk *magnestisdisk, *optiskt disk *magnetband Fysisk adressrymd - Adresser för minnet i datornsfysiska minne Logisk/Virtuell adressrymd - Abstract adressrymd som programmet använder. När ett program laddas måste logiska och fysiska minnet mappas Kontinuerlig allokering användes länge och i vissa inbyggda system. *Os och program kan nå hela minnesrymden Man kan dela upp minnet i flera fasta partiotioner som var och en kan innehålla en process (os/360 använde detta) Hur undvika att program skriver sönder andra program eller OS:et? använd en enkel MMU (memory managing unit) *Gränser (du får bara skriva mellan dessa intervall) *Basregister värden adderas till relativa adresser. *Kontrollera att ingen abs adress adresseras in i oset (endast tillåter om processen körs i kernel mode). Variabel storlek på partionerna gör att de kan växa närde behöver,men det blir lite knepigare att reallocera och det kan bildas hål när en process försvinner som inte säkert passar en ny process fragmentering löses genom att antingen kompaktera (tar mycket tid) eller att ha en enda blockstorlek (vilket ger intern fragmentering). Hur hålla reda på ledig minne? *Länkad lista med alla fria block, sorteras beroende på vilken alloceringsmetodman vill använda. *Bitmap, dela upp minnet i lika stora alloceringsblock, 0:ai bitmappen indikerar att den är ledig. För små alloceringsblock gör att bitmappen tar för mycket minne, för stora leder till intern fragmentering. Paging dela in logiska minnesrymden i sidor (Pages) dela in fysiksa minnesrymden i ramar (frames) Pages och Frames är lika stora. Använd sedan sidtabeller för att mappa pages mot frames

3 En Process alla sidor behöver inte ligga linjärti fysiska minnet (se s9 F2). Fördelar: Programmerinare tror att minnet för en process är kontinuerligt, men de kan lika gärna ligga utspritt över minnet. Nackdel: ger fortfarande intern fragmentering då inte sidorna/rames fylls helt. Vid adressering går den första biten av adressen åt att tala om vilken sida (denna byts ut mot att visa vilken ram) och resten av adressen används sedan för att ge en offset inom den sidan/ramen varje process har en sidtabell liten sidstorlek ger liten internfragmentering men stor sidtabell I/O från disk är effektivare för större datablock Trenden går mot stora sidstorlekar. vanligt är dock 4-8KB Visa system tillåter olika storlek beroende på vad som ska lagras. man kan oxå ha flernivåers sidtabeller, den yttre sidtabellen pekar på en indre sida som i sin tur innehåller flera referenser till minnet yttresidnummer inre sidnummer offset Hashade tabeller För stora adressrymde tex 2^64 krävs 5-7nivåers sidindelning, men det är för många nivåer för att vara effektivt. Vi kör dåmed hashad sidtabell, som vanligt sidnr offset sidnummret körs mot en hashfunktion och man får därifrån ramnumret Inverterad sidtabell. Om varje process har en egen sidtabell går det åt mycket minne. En inverterad sidtabell innehåller istället ett entry för varje fysisk ram och för varje allokerad sådan ett sidnr + pid för processen som har allocerat den. nackdelen med detta är att vi måste söka en hel del i tabellen, 2 lösningar, *associativt minne (DYRT!) *hasha den inverterade sidtabellen kan vara svårare att implementera delat minne. TLB Translation lookahead buffer, associativt minne, håller kvar de senaste minnesreferenserna så vi SNABBT kan finna dem igen. Leason 4 =================================== Demand paging Vi lägger till informationen i sidtabellen om sidan finns i primärminnet eller på disk. När en sida som inte finns i sidtabellen refereras till ges et sidfel, (pagefault). Dåhämtas hela sidan ut och sidatabellen uppdateras. Vi håller en lista med lediga frames. (så vi slipper leta igenomsidtabellen). UNgefär somswaping, men här hämtar vi aldrig hela processer utan sidor, page-in, page-out Med demand paging laddas sidorna endas in när de behövs. genom Pre-paging kan man försöka räkna utvilka sidor som kommer behövas.

4 Minnesaccesstid vid demand paging P = sannolikhet för sidfel m = minnesaccesstid om sidan finns i primärminnet d = tid för page-in Effektiv minnesaccesstid = (1-p)m+pd Om ingen tom rad finns, töm en ram för att skapa utrymme. Men vilken ska man tömma? två strategier *Minimera antalet sidfel *minimera I/O Om en sida man vill byta ut har uppdateras (den är dirty) tar den längre tid att byta ut än om den är oförändrad (den finns ju då redan på disken). Därför kan det vara vettigt att ha en dirtybit i sidtabellen som sätts om något skrivs till sidan. En sträng av de sidnummer vi har refererat i den ordning de har refererats kallas för referenssträng. används för utvärdering av utbytes algortimer och genereras genom trace eller analys/stokastisk analys Working set den uppsättning sidor en process refererar under en viss tidsrymd (Liten sådan) (Lokalitet) working set förändras under tiden, det som ärmest intressant är dess storlek. Sidutbytningsalgoritmen bör sträv mot att kunna hålla alla processers working set i minnet. Optimala utbytesalgoritmen på avseende av sidfel men ej implementerbar, "Byt ut den sida som det kommer ta längst tid tills den behövs igen". FIFO "First In First Out" Byt ut den som har legat längst i minnet. LRU "Least Recently Used" Byt ut den som det var längst tid sedan vi använde Den algoritm som kommer närmast optimala Dyr att implementera, kräver sökning och räkning, man måste se till att en sida som just har lästs in inte blir utstoppad igen, vanligare att man approximerar. Clock Approximation av LRU genom utvigning av FIFO "Second-chance med en cirkulär lista" En referensbit i sidtabellen, 0 när sidan laddas in, sätt till 1 när sidan refereras. När vi ska slängas sök igenom listan, om vi hittar en post som har en 1:a, sätter vi den till 0 och går vidare. Den första vi hittar som har 0:a slänger vi. Genom att kompinera Clock med NRU kan vi förbättre clock. Vi inför en modiefiedflagga som vi ettsätter när vi skriver något till den sidan. Fungerar som block men med avseendet på paret referensbit, modifierad-bit. Aging En hyfsad good aproximation av LRU räkna vid varje klockavbrott upp en räknare på alla poster i sidtabellen, addera referensbiten till vänsta biten av räknaren. VId sidfel väljs sedan sidan med lägst värde ut. Kräver dock sökning.

5 WSCLOCK fungerar som Clock men försöker hålla de sidor som ingår i Workingset kvar i tabellen om möjligt. Paging deamon när det finns ledig I/O skrev ut modifierade sidor till disk Vad gör man om man kör en instruktion och man får sidfel, och instruktionen har utförts delvis? Antingen hårdvarustöd som fixar det, annars måste operativsystemet fixa det åt oss. För att undvika att sidor som skrivs i byts ut måste man kunna stödja "Pinning" eller I/O-interlocking" Globala sidutbytesalgoritmer (som kollar alla processers sidor, istället för lokala) är oftast effektivast om en process inte får allokera tillräckligt många sidor för att hålla hela sitt working set kommer den ge många sidfel om en process spenderar mer tid på sidutbyte än påsin exekvering så "trashar" den. om vi har global sidutbytning och mnga aktiva processor kan vi få problem med att alla processer "trashar". fork / exec Normalt byter en forkad process running program kort efter att den har forkat. Men ändå kopieras hela föräldraprocessens minnesrymd till processen. Genom att inte kopiera alla processens sidor utan barar dess sidtabell? Markera dem som copy-on-write, om en sida skrivs av någon process kopiera den till barnet. i unix finns sysanroppet vfork som används för barn som direkt kommer utföra exec Hur gör windows NT? Demand paging med clustering Flera omgivande sidor läses in vid sidfel När processen skapas får den allokera ramar enligt. working-set-minimum working-set-maximum Virtuell minneshanterare håller en lista med lediga ramar Om systemet har för få lediga ramar tar minneshanteraren ramar från processer som allokerat fler än working-set-minimum ramar. Utbytesalgoritmer: 1st cpu x86, variant av Clock nst cpu, alpa, variant av FIFO Hantering av Sekundärminne vid swap Kontinuerlig allokering på disk, enkel adressöversättning svårt att klara ökad storlek man kan tänka sig att ha olika utrymmen för text, heap, stack men det hjälper bara till viss del. Dela upp disken i delar (samma storlek som sidor håll en tabell motsvarande

6 sidtabell för var sidorna på disen lagras Segmentering var tidigare alternativet till sidindelat minneshantering men används nu ofta tillsammans med sidindelning + Naturlig uppdelning av minnesrymden - Kontinuerlig allokering är svår - Kan kräva att programmeraren är mer medveten om minneshanteringsmodellen för att kunna utnytja den. Ha ett segment för text, ett för heap och ett för stack, dessa kan sedan växa utan problem oberoende av varandra Leason6 ========================================== Filsystemets främsta uppgift är att erbjuda långtidslagring Filssystemet är ett abstraktionslager över fysiska diskarna Bör tillåta användarna att organisera sina filer lättöverskådligt. Accessmetoder - Hur läser / skriver man filer? Sekvensiell access man läser/skriver en följd av bytes möjlighet till positionering saknas. Tex I/O mot ett tangentbord. Random Access Man kan positionera sig i filen för skrivning/läsning Andra accessmetoder, tex indexerad access i databas. Implementeras med random access tillsammans med extra struktur inom applikationen En nivåers, två nivåers eller flernivåers directory structurer Varför tillåter man inte cykler i directory strukturen? Svårare att göra rekursiva anropp som listar hela trädet. För att slippa läsa/skriva till/från disk kan en process ofta mappa in filen i sitt adressutrymme. I/O går mot minnet istället för mot disk (snabbare). Men när ska vi skriva tillbaka till disk? Om inte tidigare så måste vi göra det när vi stänger filen. eller närvi explicit säger att vi vill göra det. Varje disk innehåller en MBR som innehåller partitionstablellen. på varje partition finns sedan en boot block som talar om vad som ska bootas,och ett superblock som innehåller alla filsystemets parametrar, hantering av ledigt utrymme ev I-noder, root directory och sedan minnesarea Allokering av minne på filsystemet Kontinuerlig allokering, samma problem som i minnet, funkar dock mycket bra för media som bara skrivs en gng (cdrom). Blockindelad allokering Dela in minnet i block, allocera med länkad lista (länken finns i blocket), blir dock långsamt vid random access (måste gå igenom alla block för att hitta dit vi vill). FAT File allocation Table,separat tabell i minnet med pekare till block. Indexerad allokering, påminner om sidtabell i minnet.

7 Blockstorlek Medianstorleken på unixsystem = 1kB I/O mot diskm små block = mycket overhead -> helst större block 512b-8kB har används (i msdos beroede blockstorleken på diskens storlek) I-node (index-node) innehåller en pekare till varje block som tillhör en viss fil, föredelen mot länkade listor eller FAT är att I-noden endastbehöver vara öppen när just den filen är öppen. Varför måste man öppna/stänga filen innan man skriver den/slutar använda den? OS håller reda på accessrättigheter vilka som har filen öppen Var man är positionerad i filen. vid stängning håller os reda på Hur många som har filen öppen, om filen buffrats och behöver skrivas till disk. Hur hålla reda på ledigt minne? *Bitvektor (växer med ökad diskstorlek och minskad blockstorlek) *Länkade listor som byggs i det fria utrymmet (kräver inget extra utrymme). Länkar i unix länk, fil som innehåller filnamnet till en fil eller dir. Hårdlänk Får bara peka ut filer Uppdaterar räknaren i den utpekade filens i-node för hur många som refererar filen. en fil kan ej tas bort så länge denna räknare är > 0 Mjuk länk Kan peka ut både dir och file. ränar inte upp räknaren. Leason7 ================================ I/O huvudklasser: Blockdevices Läser och skriver block av data (read, write,seek) Diskar, cdrom, band Character-devices Skriver/läser strömmar av tecken put, get tangentbord,skrivare, nätverk Det är dyrt med interuppt (Måste byta process till avbrottshanteraren i kärnan) DMA - Direct Memory Access En hårdvaruenhet som kan instrueras att överföra en mängd data (blovk) till/från en minne och någon I/O enhet Den "buffer" som håller det som ska skrivas ut/läsas från I/O får inte pagas ut, därför pinnas det i minnet En i/o enhet kan ofta ha fler än en i/o operation igång samtidigt. Drivrutinskoden måste därför vara re-entrant. Hårddisken indelad i spår med ett antal sektorer per spår.

8 Diskarmsschemaläggning FCFS - First come First served SSF - Shortest Seektime first SCAN, C-SCAN Hissalgoritmer LOOK, C-Look Leason 8 Trådar En tråd är en "process" inom processen. Trådar inom en process delar kod, heap och filer billigare att skapa och processswitcha trådar jämfört med processer Kan enkelt fås att använda flera cpuer Trådar kan antingen köras i kernel-space eler i user-space pthreads, solaris har både userspace ochkernelspace trådar i win heter det fibers Java implementerar trådar i den virtuella maskinen, men dessa är svåra att klacificera som user-space eller kernel-space Snabbare datorer: Öka klockfrekvensen -går inte så mycket mer -varmt Öka antalet processorer Multicpu datorer datorer i network flera cpu per chip att ha cpu:ern på en gemensam bus begränsar antalet cpuer till ~20st nät, antal cpuer upp till 1000st schemaläggning på multicpu, för lastballansering och rättvihet är det bäst med en readykö för alla cpuerna. men för att effektivt utnyttja cache etc är det bättre om en tråd får köra på samma cpu somden körde senast Trådar från samma job/process bör få köra tillsammans annars är risken för deadlock vid blockning Gang Scheduling alla trådar i en process kör samtidigt på olika cpuer Alla cpuer byter process samtidigt Om en tråd blir BLOCKED blir det cpu idle (väntar in övriga cpuer) Pipes, har en viss storlek om en process vill skriva och den är full så måste dne vänta. om en process vill läsa och den är tom så måste den vänta Leason9 ===================================================== RPC Stateless state? server cache

9 Leason10 ===================================================== Racecondition två processer tävlar om en gemensam resurs Ömsedidig uteslutning Via lås eller semaforer Deadlock, en process blockas pga att den väntar på att en annan process ska göra något. den har tex låst en resurs som processen behöver Coffmans vilkor: Ömsesidig uteslutning endast en process åt gången kan använda en resurs Behåll o vänta en process kan behålla (reservera) resurser medans den väntar på att få andra. Ingen pre-emption (konfiskering) Resurser kan inte tas från en process Cirkulär väntan det måste finnas en cykel av processer där varje process väntar på att få en resurs av nästa Hantering av deadlock * Gör ingenting, (det är dyrt o svårt att undvika detekta deadlocks) * Kontrollera utgivandet av resurser och leta cykler. * var försiktig (begränsa processerna) Återhämtning efter deadlock * Pre-emption - Ta tillbaka resurser * Roll-back - Gå tillbaka till en tidigare punkt * Döda processer, tillslut måste det lösas upp Att alldrig hamna i baklås * Bankiralgoritmen Bygger på att systemet kan kontrollera schemaläggningen av processerna (vissa scheman leder till baklås andra inte). Varje process anger sitt resursbehov i förväg. SYstemet befinner sig alltid i ett "säkert" läge, om en request kommer som skulle placera systemet i ett osäkert läge körs en anna process istället så länge - Inte ofta varje process vet exakt hur mycket processer och när den behöver den innan exekueringen börjar. Kan dock fungera i batchsystem * Bryta något av Coffmans vilkor Kan lösa hela probelmete Bryt omsesidig uteslutning, ingen process får låsa en resurs. Hur gör vi då då? skapa en demon, (printer tex) som håller en kö, låt sedan den göra alltjobbet med de jobb som läggs på kön Bryta Hold-and-wait Kräv att en process släpper alla sina resuser när den begär en ny, eller begär alla samtidigt Bryta no-preemption Visa resurer kan konfiskeras

10 Bryta cirkulär väntan Ge alla resurser ett nummer, det är bara tillåtet att allokera resurser i stigande ordning Livelock En grupp processer som exekverar men inte kommer vidare eftersom de hela tiden synroniserar med varandra. Svårt att upptäcka då processerna inte blockar utan fortsätter exekvera när de försöker synca med varandra Svältning En process får aldrig köras då andra processer hela tiden körs före den. Om man har alla jobb när man börjar köra och vet deras körtider är Shortest Jof First optimal. Men man kan råka ut för svältning, säg tex att ett jobb med körtid 10 och ett med körtid 5 kommer int, dessutom kommer det hela tiden in nya korta job, då kommer 10 jobbet aldrig att köra Lösning på aging *Man kan ge processer som har väntat längre suskesivt högre prio, (aging). *Undvik prioriteter helt, alla processer har samma prioritet och ingen schemaläggning görs Kolla Dining philosofers Sleeping barber Bounded buffer Readers and writers Leason11 ===================================================== Mål med kryptering om en förbrytare kommer över det cryptade ska det ta så lång tid för honom att bryta så det inte spelar någon roll Symmetriska system Samma nyckel för crypt som för decrypt Public key Ćrypt och decrypt är olika, (RSA) Envägs funktioner y=f(x) givet y och f är det mycet svårt att beräkna x Mycket sunt förnuft Leason12 ===================================================== Realtidsoperativsystem Har jobb som måste lösas inom givna tidsramar.(får aldrig missa deadline) Ett job är oftast en liten beräkning eller sensoläsning Ett jobb har starttid S, Maximal Beräkningstid C (critical path) och deadline D S+C<=D (annars går det inte) P Periodiska job Ett job som utförs regelbundet tiden mellan 2 starttider är dess period Ett system med bara periodiska jobb kallas periodiskt

11 Aperiodiska jobb jobb som förorsakas av någon händelse Vanligt är att realtids operativsystem innehåller både periodiska och aperiodiska jobb. Hårda system I ett hårt system får man inte missa deadlines iom att det medför fatala fel. Mjuka system Man bör eftersträva att hålla deadlines men skulleman missa någon enstaka är det inte katastrof. Mer eller mindre viktiga (hårda) jobb, anges som en vikt. Vid en inbromsning är det viktigare att bromsningen funkar än att motorn går optimalt Hårda realos kräver att man inte råkar ut för fördröjningar, därför saknar de oftast Virtuellminne (pagin/pageout), filsystem och många andra I/O enheter. Data lagras oftast i ROM mjuka realtid kan köras på de flesta os. måste kunna pre-empty processer så vi inte slösar tid på att vänta i onödan schemaläggning i realtidsos Mål klara alla deadlnes gälla För att ett periodiskt system ska vara schemaläggningsbart måste följande sum(ci/pi) <= 1 C/P är andelen av perioden som en processs måste få exekvera. Jacksons regel Varje schemaläggning som ordnar processerna efter strikt ökade deadlinetider är optimala Schemaläggningsmetoder Rate Monotonic scheduling En process med högre prio kan avbryta den körande och gå före den i kön Earliest deadline first Den process som har kortast tid kvar till sin deadline är den som får köra först. Optimal enligt Jackssons regel, men kan ge dominoeffekt av jobb som missar sina deadline vid överlast Smiths regel antag att varje process har en vik w som anger hur viktig den är. En schemaläggning är optimal som schemalägger processerna i icke-avtaganade ordning efter C/w Delade resurser är gör det svårt att schemalägga Earliest deadline first är icke-optimalt om man har flera processorer Device Drivers Vilken kod ska devicedrivrs innehålla?

12 Kod för systemanrop Kod flr avbrottshantering Kod för initialisering Kod för att städa upp om drivern tas bort Är en svart kåda som ska sköta styrningen av hårdvaran Bör implementera mekanismer för att hantera enheten inte policy, förutom när det gäller säkerhet då man kanske vill kontrollera lite). Man måste få tillsäkerheten rätt koden måste vara reentrant, är oftast i c/asm och måste hantera parallelism Device (driver) typer i linux Character device Block device Network interface CHar och block hanteras som filer open, read, werite, close Network interfaces Syns i filsystemet hanterar paket istället för för strömmar. MOduler används för att dynamiskt länka in device drivers Ska ha kod för registrera funktioner hos kärnarn initiera data kod för upprensning Leason13 linux fil orienterat Processer / trådar Processhirearki Windows objectorienterat (ej arv,polymorfism) HAL hardware abstraction layer Registret, stor databas som innehåller systemets alla inställningar Tråd Enhet för schemaläggning i cpu Fiber lättviktsprocess i userspace Ingen processhirearki createprocess() tar 10 arg Schemaläggning Unix 2nivåer lågnivå Välj nästa process som ska exekveras Prioriteter -20 <-> 20 processer i userspace har positiva prio en process använder sin tidsquantum (100ms) eller tills den blockar Optimarea för mycket interaktiva processer Högnivår Flytta processer till från minne (swap) Linux schemalägger trådar tre klasser

13 Realtime FIFO Realtime round robin (kan preempty av clock interupt) Timesharing Grundprioritet + nice = 0-40 Individuell tidsquantum för varje process Basseras på goodnes som är uträknat av prioritet, utnyttjad tids quantum En cpu stoppas om Den förbrukat sin quantum Ben blockeras En tråd med högre goodnes blir körbar När det inte finns några körbara trådar kvar (alla blockerade eller quantum=0) beräknas quantum om enligt quantum/2 + prioritet. Detta ger företräde åt I/O bundna processer Cpu-bundna processer får cputid i förhållande till sin prio. Windows Schemalägger trådar och bryr sig inte alls om processer Högt numeriskt värde = Högprioritet 7 grundklasser för trådar + 6 nivåer inom varje klass => Basprioritet 1-42 Schemaläggning körs av: en tråd om tråden blockera för I/O tråden signalerar ett object (tex på semafor) trådens tidsquantum är slut an andra derla om en I/O operation blir klar en tidsbegränsad wait blir klar. Minneshantering 32bitars Windows maximal adressrymd 4GB Av detta mappas os in på drygt 2GB Gör det snnabar att gå från user-mode till kernelmode 2GB är oftast för lite, servervarianten tillåter 3GB/process Bank switchning sidindelat virtuellminne, redn demand pagin