Please enable JavaScript.

Coggle requires JavaScript to display documents.

sistemi operativi risposte orale, risposte veloci esercizi - Coggle Diagram

- - - - fetch, decode, exec avvengono linearmente
    - - holding buffer x interrupt
  - - - rimozione senza effetti dannosi
    - - causa falimento processo
  - - - hard
        
        scadenze assolute, senò provoca crash
      - soft
        
        scadenze strette, senò provoca problemi ma no crash
  - - - sconsigliato perchè se si dimentica di riattivarli il sistema finisce
  - - - variabile lock
        
        prima soluzione per mutua esc.
        
        variabile condivisa = 0 (= regione critica disp)
        
        imposto 1 quando entro, 0 quando esco. il problema è la concorrenza su questa variabile:
        
        TSL: istruzione assembly atomica per controllo e accesso a regione critica.
      - alternanza stretta
        
        variabile "turn" per alternare accesso tra 2 processi
        
        svantaggi: provoca busy waiting (se ciclo medio lungo) espreco di tempo.
        
        problem: uno dei due processi è più veloce -> inconsistenze.
        
        soluz: applico alternanza solo quando so già velocità (come spool file)
      - Paterson:
        
        funzioni:
        
        enter_region
        
        leave_region
        
        quando processo 0 accede a enter_region, imposta variabile turno lista interessati con il suo valore a true
        
        se interest(n-1) è false, posso entrare in regione
        
        se interest(n-1) è true, devo aspettare che finisca (eseguendo leave_region)
  - - - burst più lunghi
    - - burst corti, attendono risposta dispositivi periferici
  - - - avvio processo
      - termine processo
      - dopo ricezione interrupt
      - quando processo si blocca su IO
    - - con
        
        se passa troppo tempo in esec posso cambiare processo
      - senza
        
        eseguo fino fine istruz o errore, gli altri wait
    - - FCFS
        
        ordine d'arrivo
        
        non molto conveniente se ho proc cpu-bound molto più grandi di io bound
      - SJF
        
        senza prelaz
        
        prima processo più breve (rispetto al tempo di arrivo)
        
        con prelaz
        
        chiamato anche SRTN, scelgo per il tempo attuale quello con tempo min rimanente
        
        SPN (shortest process next)
        
        SJF per sistemi batch in sistemi interattivi
      - Round Robin
        
        quanto di tempo: burst processo seguendo ordine arrivo fino max quanto di tempo, po torna in coda.
        
        quanto di tempo
        
        breve
        
        job lunghi troppa attesa
        
        lungo
        
        troppi cambi contesto, spreco cpu aumenta overhead
        
        scheduling a priorità
        
        ogni processo ha priorità. prima priorità alta e poi quella bassa
        
        eseguo per gruppo di priorità e all'interno dello stesso gruppo eseguo round robin.
      - code multiple
        
        quanto di tempo != per ogni processo per ogni liv di priorità
        
        se processo completa tutti i quanti viene abbassato di priorità, così se processo esegue per molto tempo, poi diventa interattivo, non viene penalizzato
      - guaranteed
        
        utenti, stessa capacità CPU, 1/numero utenti
      - lottery
        
        distribuzione biglietti e estrazione randomica
        
        allocazione priortà distribuendo + biglietti a stesso processo
      - fair share
        
        ognuno può runnare finchè finiamo potenza calcolo. divisione equa per la necessità attuale
      - nei sistemi real time
        
        deadline based.
        
        periodici
        
        deadline fisse
        
        non periodici
        
        deadline improvvise, difficile prevedere
        
        condizione schedulabilità: sommatoria frazione ogni periodo/tempo cpu per evento
        
        se <=1 può essere rispettata schedulabilità
        
        possono essere
        
        dinamici
        
        scheduling in corso d'opera
        
        statici
        
        durata processi conosciuta, garanzia scadenze, scheduling deciso in anticipo
  - - - chiamo funzione, push stack e poi jump a prima istruzione
  - - - resident monitor
      - user area
- - - - soluzione: uso intermediario (spooler stampante) che gestisce coda richieste
      - meccanismi risoluzione prod-cons
        
        semafori
        
        usati per risoluzione problema prod-cons
        
        variabili semafori:
        
        empty: semaforo traccia posti vuoti
        
        full: semaforo traccia posti pieni
        
        mutex: garanzia mutua escl durante accesso risorse
        
        down quando accedo alla lista condivisa risorse. up quando lascio la lista condivisa
        
        int speciale > 0. è 0 se non ci sono wakeup in attesa, di più se ci sono wakeup in coda
        
        operaizoni atomiche:
        
        down: consumo risorsa se ce ne sono disp
        
        up: rilascio risorsa
        
        mutex: semaforo binario
        
        stati:
        
        locked
        
        unlocked
        
        operaz: mutex_
        
        lock
        
        unlock
        
        futex: fast user mode mutex
        
        diminuisce quantità chiamate al kernel per scambio thread corrente.
        
        componenti
        
        2 more items...
        
        funzionamento: thread cerca di accedere, se non può va in lista kernel, poi viene eseguito e poi esce dalla regione critica
        
        funzionamento mutex in Pthread (POSIX thread)
        
        strumenti sincronizzazione thread usando mutex
        
        aggiunta chiamate per creazione, distruzione e cambio stato mutex oltre che chiamate blocco sblocco thread in base a wait o signal
        
        risolve prod-cons
        
        monitor
        
        alto livello, raccolta procedure, variabili, strutture dati accessibili da processi con condizione che solo 1 proc può essere dentro a monitor.
        
        funzionamento
        
        check che posso accedere
        
        uso variabili wait e signal per comandare thread
        
        sono diversi da sleep e wakeup perchè se processo è dentro struttura monitor, è garantito di aver tempo di eseguire wait senza che un altro processo lo risvegli prima del dovuto
    - - vera soluzione, rimuovere prelaizone, processo chiede tutte risorse prima dell'esecuzione
        
        2 phase lock
        
        blocco record necessari
        
        se riesco, eseguo aggiornamenti e rilascio blocchii
        
        se non riesco restituisco risorse bloccate e ricomincio (possbilità deadlock qui)
    - - ordinamento globale: posso richiedere risorse solo in quell'ordine
  - - - algoritmo dijkstra risoluzione deadlock
        
        ogni nodo N grafico, effettua 5 passi con N come inizio:
        
        initialize L lista vuota e disegna archi unmarked
        
        add nodo corrente in coda e L controlla se appare 2 volte lo stesso
        
        se si, algoritmo termina, trovato deadlock
        
        se ci sono archi unmarked passa al punto dopo. senò all'ultimo
        
        scegli arco unmarked, seguilo e vai al passo 3
        
        se nodo = nodo iniziale, grafico non contiene cicli
        
        algoritmo termina, no deadlock
        
        se nodo non è iniziale torno indietro di un nodo e torno a punto 3
        
        s
      - soluzione: introduzione prelazione, revoco temporaneamente risorsa a processo (non applicabile a tutte le risorse)
      - rollback, torno indietro fino a quando non avevo deadlock, molto costoso
      - killo processo che genera deadlock
  - - - stato non sicuro garantisce la convergenza in deadlock ma non è stato di deadlock
    - - risorsa singola
      - risorsa multipla
      - argomento: stato sicuro. come banchiere tratta gruppo clienti a cui ha garantito credito.
      - implementazione:
        
        matrici istanze assegnate, matrici istanze necessarie
        
        3 vettori:
        
        E=esistenti
        
        P=possedute
        
        A=disponibili
        
        funzionamento: se stato sicuro, almeno un processo può terminare assegnando A. se no può andare in deadlock
  - - - soluzione: timeout protocolli rete, dopo un po' rimando tutto
- - - - eseguito su calcolatore, necessaria manutenzione
      - ogni sis virtualizzato ha os che va mantenuto
      - os ospitante è spf (single point of failure)
  - - - chiedo a qualcuno di tenere il mio hardware e manutenerlo
    - - affitto macchina virtuale, risolvo problemi manutenzione ed è più modulare
  - - - utente finale (google)
    - - SO virutale pronto, x sviluppatori (google engine)
    - - controllo remoto HW, x architetti sistemisti (AWS)
  - - - efficiente uso risorse: conviene a provider, adattabile a cliente
      - elastico: scalabilità quindi flessibile
      - no manutenzione esterna: scalabilità automatizzata
      - accessibile e sempre online
  - - - pubblica amministrazione, più entità
- - - - compressione = modo di codificare, piacevole conseguenza
        
        parametri difficili da valutare
        
        mezzo fruizione: limite tecnologico
        
        agenti fisiologici: tipologia info diverse, percezione diversa
        
        agenti psicologici: riconoscimento istintivo umano, filtro rumore automatico
    - - necessario ricaricamento buffer se faccio seek
        
        soluzione: tempo elab più costante possibile
      - parto da I-frame più vicino (es yt)
        
        tempo estrazione più uniforme possibile
  - - - sicurezza
      - cifratura
      - protezione intellettuale
      - affidabilità
      - side effect: compressione
      - evitare errori trasmissione
    - - standard percezione audio video
      - codifica asimmetrica: codificatore lavora + di decodificatore (hardware utente ha la priorità di ottimizzazione)
    - - container: dichiara sintassi scrittura bit su file.
      - codica: modo con cui info audio-video va trattata
  - - - no perdita, previsione
        
        GOP
        
        I-frame: no prediction, key frames
        
        P-frame: prediction on future movement
        
        B-frame: bilateral prediction, past and future. In between frame
    - - spaziale: colore omogeneo
        
        soluz: codifiche separate per colori YUV. immagine viene pulita da basse frequenze tenendo solo contorno oggetti. Tutti i valori si esprimono per differenza dal primo
      - temporale: stessi contenuti in due istanti (sfondo uguale)
        
        soluz: frame diviso in macro blocchi poi ricercati senza ricodificare. Applico motion vector per spostamento blocchi, no necessità ricodifica
  - - - os è impegnato a fare altro o interrupt sist, IBP frame hanno tempi rendering diversi.
        
        soluzione: buffering. arrivo irregolare -> output regolare
        
        se buffer troppo grande, risorse sprecate e ritardi inaccettabili
  - - - RMS (Rate Monothonic)
        
        burst ogni processo deve terminare entro suo periodo
        
        no dipendenze fra processi
        
        burst richiesti sono = per periodo
        
        overhead prelazione cpu si presume trascurabile
        
        processi non periodici sono schedulati solo se cpu libera
      - EMS (Earliest Deadline First)
        
        variante RMS con priorità dinamiche. Ogni processo ha priorità inversamente proporzionale a deadline. non necessario che processi siano periodici o burs identico
  - - - memorizzo file su disco modalità sequenziale, con codifica e container
    - - aggiunta file metadati (memorizzano maniera sequenziale posizione i frame seguito da GOP)
        
        se dim blocco disco < GOP uso "frame index"
        
        allocaizone sequenzale senza spreco spaizio
        
        se dim blocco disco > GOP uso "block index"
        
        non gestisco accessi sequenz ma introduco framm interna
- - - - volume groups
        
        logical volumes (partizioni)
        
        filesys
    - - group extent, simbolizza phisical extent dentro volume group
  - - - memorizzazione alternata
    - - scrittura prossimo disco se pieno
  - - - striping: velocità
      - mirroring: affidabilità
- - - - dispositivi hanno buffer dati per evitare IO frequente.
        
        cpu comunica 2 modi:
        
        ciascun registro controllo è assegnato a numero porta IO. forma un insieme e proteggo da accesso programmi.
        
        mappatura in memoria:
        
        vantaggi
        
        registri = variabile in memoria, non serve assembly
        
        no meccanismo protezione, "intrinseco"
        
        ogni isturzione che referenzia memoria, può referenziare registri controllo
        
        svantaggi
        
        rischio loop se memoria è in cache
        
        soluzione: uso bus dedicato cpu-memoria +prestazioni
  - - - cpu imposta registri
      - trasferimento memoria a disk controller
      - scrittura main mem in un indirizzo usato dal bus
      - controller disco manda ack al dma. segue interrupt da DMA a CPU
    - - word-by-word
        
        cpu cycle stealing
      - modalità blocco
        
        cpu burst
  - - - componente scheda madre, tiene la coda degli interrupt generati. e li gestisce
        
        riceve interrupt da periferiche e manda segnale interrupt per attrarre attenzione
      - numero linee indirizzi
        
        indice tabella chiamata vettore
        
        prelevo nuovo contatore programma per nuova istruzione
    - - perciso
        
        lascia macchina stato definito
        
        pc conosciuto
        
        istruzioni precedenti completate
        
        solo istruzione pc è in esec
        
        stato esecuzione pc corrente conosciuto
        
        vantaggio: ripristino istruzioni
        
        svantaggio: pesante
      - non preciso
        
        non rispetta le 4 regole
        
        vantaggio: più snello
        
        svantaggio: irreversibilità azioni
  - - - kernel
      - utente
      - ibrido
        
        più sicuro, evita perdita dati
- - - - FAT
        
        svantaggi
        
        per funzionare permane in memoria
        
        vantaggi
        
        risolve eliminazione accidentale. basta blocco di partenza ed è tutto ricondicibile
      - contigua e liste
        
        vantaggi
        
        svantaggi
      - i-node (tracciano blocchi del file)
        
        vantaggi
        
        rispetto FAT, non permane in memoria.
        
        svantaggi
        
        se file supera limite indirizzi disco, ultimo indirizzo è un rimando a altri blocchi liberi
        
        in UNIX
        
        1 inode 1 file con metadati e puntatori. uso path per localizzare voce directory.
        
        forma albero, da root con link formo un grafo aciclico orientato.
        
        ogni entry directory UNIX: nome file, numero i-node file
    - - limito a 255
      - limite personalizzato per directory (non efficace)
        
        optim: + nomi in heap. Se rimuovo voce, file successivo ci starà
      - x velocizzare:
        
        nomi nella cache
        
        tabella hash
    - - file system diventa grafico aciclico
      - vantaggi
        
        comodo
      - svantaggi
        
        copia indirizzi della directory, non rimane aggiornata dopo le modifiche
        
        soluzione
        
        struttura dati associata
        
        file di tipo link con dentro path
        
        cancellazione file
        
        tentativi con link simbolici falliscono
        
        conclusione: appesantisce gestione dato
    - - scopo: definire e tracciare locazione e struttura filesys
      - sono particolari FILE
  - - - accoppiano syscall posix con chiamate specifiche FS sottostante
  - - - se job successo = cancello log
  - - - blocchi troppo grandi: piccoli file sprecano spazio
      - soluzione
      - blocchi troppo piccoli: file grandi = + ricerche e rotazioni disco, spreco tempo
    - - free list
        
        blocchi liberi tracciano libertà altri blocchi
        
        svantaggio
        
        quando si riempe lista, viene spostata in memoria generando IO
      - bitmap
        
        dico n blocchi ha anche bitmap n bit. blocchi liberi = 1, occupati = 0
        
        vantaggio
        
        occumpa meno spazio, 0 IO
    - - controllo su blocchi
        
        2 tabelle: 1 contatore = 1 blocco, tutto a 0
        
        1a
        
        n volte blocco è presente in file
        
        2a
        
        n volte blocco presente blocchi liberi
        
        0 e 0: mancante -> libero
        
        1 e 1: ricostruisco lista
        
        situazione peggiore se presente in 2 o + file: alloco blocco libero, copio contenuto blocco colpevole in uno dei file.
      - controllo su file
        
        discesa ricorsiva albero directory daroot. +1 contatore per i-node trovato (link non contano)
        
        confronto consistenza numero con contatori dei collegamenti in i-node
        
        soluzione: forzo contatore i-node a quello misurato
      - controllo file e blocchi eseguito insieme
  - - - genero hash dal dispositivo e indirizzo disco. cerco risultato in tabella hash
    - - se c'è: restituisco
      - se non c'è: applico FIFO, doppia chance e lru
        
        spesso LRU modificato. Se blocco serve tra poco è fondamentale per consistenza. divisione per criticità.
  - - - dischi/periferiche affiancate a quella col fs
    - - non ha dischi montati esternamente. sono direttamente in root, agganciando filesys periferica a SO
- - - - da hardware fino a prima di os
        
        assembly, codice macchina
      - da os a interf utente
        
        codice più semplice, human readable
  - - - memorybus
        
        collega IO bridge a memory bus a memoria principale
      - IObus + bridge
      - sysbus
        
        collega CPU direttamente a IO bridge
    - - avendo bus a parte, segnali arrivano più velocemente e prestazioni aumentano
  - - - più diffusi, os eseguito come programma singolo modalità kernel. Raccolta procedure. ogni procedura ne chiama altre
    - - struttura
        
        livello 1: memoria
        
        livello 2: comunicazione fra processo e console operatore
        
        livello 0: allocazione processore
        
        livello 3: dispositivi IO
        
        livello 4 programmi utente
        
        livello 5: operatore
      - no scorciatoie, per andare da un livello all'altro passo da intermedi
    - - stabilità grazie divisione piccoli moduli
        
        funziona solo modalità kernel, gli altri processi utente, driver dispositivo, fs è separato, qunidi malfunzionamento di essi non intacca il cuore
    - - macchine, usando paradigma client-server (funzionamento cloud)
  - - - programma principale (kernel)
      - procedure servizio
      - procedure supporto (livello utente)
- - - - burst identico: scelta arbitraria
  - - - stesse regole sjf
- - - - settato a 1, se referenziato +1
        
        elimino il primo che trovo a 0 (man mano che passo diminuisco counter)
        
        segno da che posto ho iniziato a controllare i bit e aumento (verso l'alto) ogni volta
        
        i nuovi entrano in alto
  - - - elimino frame sottostante, schiaccio in basso e inserisco in alto
  - - - i nuovi entrano in alto??
  - - - i nuovi entrano in basso