Primo modulo (SC1)

Martedì 30 settembre 2014 (180 min)

• Panoramica del corso e suo inquadramento nell'ambito complessivo degli esami di informatica del corso di laurea
• Esempio di come l'architettura del sistema impatta sulle prestazioni: scansione per righe e per colonne di una matrice
• Uso del tool Valgrind per il debugging dell'uso della memoria
• Complementi del linguaggio C:
  • Interpretazione delle espressioni di tipo
  • Puntatori a funzione: esempio del comparatore nella funzione qsort
  • Oggetti e valori: nozioni di Lvalue e di Rvalue
  • Definizione degli operatori * e & basata su Lvalue ed Rvalue

Giovedì 2 ottobre 2014 (90 min)

• Introduzione ai sistemi di calcolo: sistemi a nodo singolo e multi-nodo
• Struttura generale di un calcolatore basato sull'architettura di Von Neumann: CPU, bus, I/O bridge, memoria, controller e adattatori
• Stadi della compilazione di un programma C: preprocessamento, parsing e compilazione in linguaggio assembly, compilazione in linguaggio macchina, linking

Martedì 7 ottobre 2014 (180 min)

• Compilatori e interpreti: vantaggi e svantaggi dei vari approcci
• Linguaggi di alto e di basso livello
• Toolchain gcc: cpp, cc1, as, ld
• Compilazione separata di moduli C: errori tipici (simbolo non definito, simbolo definito più volte)
• Riepilogo rappresentazione dei numeri esadecimali
• Analisi di file ELF (file oggetto, file eseguibili) mediante il comando objdump: disassemblamento di codice macchina x86
• Operazioni utili mediante comandi di shell:
  • pipe | e redirezione dell'output >
  • comando less per paginare un flusso di testo
  • comando bc come calcolatrice da riga di comando (cenni)
  • comando sort per ordinare le righe di un flusso di testo (cenni)
  • comando man per visualizzare la documentazione di programmi
  • comando file per l'analisi del tipo di file
  • comando hexdump -C per l'ispezione di file binari
• Processi come programmi in esecuzione:
  • PID di un processo
  • Elenco dei processi in Linux/MacOS X: il comando ps -e
  • Eliminazione di un processo: il comando kill
  • Immagine di memoria di un processo in Linux/MacOS X: sezioni testo, dati, heap, librerie, stack
  • Analisi delle sezioni di un processo Linux: la directory virtuale /proc e lo pseudo-file maps
  • Sezioni di appartenenza di funzioni C, variabili globali, locali, parametri formali e blocchi allocati dinamicamente
  • Sezioni in sola lettura, sezioni eseguibili

Giovedì 9 ottobre 2014 - esercitazione (90 min)

• Esercitazione di laboratorio 1
  • File e directory
  • Shell bash: comandi interni ed esterni
  • Comando xxd per trasformare file binari in file di testo e viceversa
  • Passaggio dei parametri a un programma C mediante argc/argv

Martedì 14 ottobre 2014 (180 min)

• Nozione di Instruction Set Architecture (ISA) come astrazione di macchina di calcolo
• Schema generico CPU: ALU, controllo, register file (set registri)
• Registri dell'ISA IA32
  • Registro instruction pointer (program counter): EIP
  • Registri general-purpose: A, B, C, D, DI, SI, BP, SP
  • Registro dei FLAG
  • Altri registri (virgola mobile, ecc.)
• Livelli di accesso ai registri: suffissi b, w, l
• Sintassi AT&T (GAS) e Intel (cenni)

Giovedì 16 ottobre 2014 (90 min)

• Registri come stato della macchina non accessibile a un programma C
• Modi di indirizzamento
  • Immediato
  • Registro
  • Memoria (assoluto, indiretto, base/spiazzamento/scala)
• Indirizzo effettivo
• Formato delle istruzioni macchina: formato fisso vs. variabile (cenni)
• Processori RISC e CISC (cenni)

Martedì 21 ottobre 2014 (180 min)

• Set istruzioni ISA IA32:
  • istruzioni di movimento dati: mov, movz, movs, push, pop
  • istruzioni aritmetico-logiche: inc, dec, neg, add, sub, imul, and, or, not, xor
  • riepilogo tabelle verità operatori logici: not, and, or, xor
  • operatori bit a bit in C: ~ (complemento a uno), & (and bit a bit), | (or bit a bit), ^ (xor bit a bit)
• Rappresentazioni little-endian e big-endian
• Esempi di compilazione di programmi C in codice x86-64:
  • assegnamenti e istruzioni aritmetiche
  • conversioni di tipo (es. da short a int)
• Complementi: cenni alle variabili di ambiente della shell (es. variabile PATH)

Giovedì 23 ottobre 2014 (60 min)

• Esercitazione di laboratorio 2
  • Operandi e modi di indirizzamento della memoria IA32
  • Istruzioni di movimento dati IA32
  • Istruzioni aritmetico-logiche IA32

Martedì 28 ottobre 2014 (180 min)

• Esercizi su:
  • modi di indirizzamento
  • istruzioni di movimento dati (mov, push, pop)
  • istruzioni arititmetico-logiche
• Istruzioni di shift logico e shift aritmetico

Giovedì 30 ottobre 2014 (90 min)

• L'istruzione LEA (load effective address) e il suo uso per calcolare espressioni aritmetiche su interi e puntatori
• Istruzioni di salto: salti incondizionati diretti e indiretti
• Codici di condizione: flag ZF (zero), SF (sign), CF (carry), OF (overflow)

Martedì 4 novembre 2014 (180 min)

• Esempi di come gcc compila assegnazioni e calcolo di espressioni aritmetiche
• Istruzioni di salto condizionato basate sui codici di condizione
• Istruzione cmp
• Traduzione delle istruzioni di selezione if ... else in linguaggio assembly IA32

Martedì 11 novembre 2014 (180 min)

• Traduzione delle istruzioni di ciclo while e for in linguaggio assembly IA32
• Esercitazione di laboratorio 3
  • Istruzione load effective address IA32
  • Istruzioni di jump condizionale IA32
  • Esempio di uso dell'istruzione leal nei compilatori C

Giovedì 13 novembre 2014 (90 min)

• Chiamate e ritorno da funzione: call e ret
• Nozione di chiamante (caller) e chiamato (callee)
• Registri caller-save e callee-save

Martedì 18 novembre 2014 (180 min)

• Trasferimento condizionale di dati con le istruzioni cmov
• Array: rappresentazione in memoria, confronto con il C, aritmetica dei puntatori
• Stack frame IA32
  • Ruolo del registro %ebp
  • Istruzioni di trasferimento del controllo (call, ret, leave) e convenzioni sulla manipolazione dello stack frame
  • Indirizzo di ritorno
  • Dati locali (variabili, array, etc.), registri salvati e valori temporanei
  • Passaggio di parametri

Giovedì 20 novembre 2014 (90 min)

• Esercizi sulla compilazione di programmi C in assembly IA32:
  • somma degli elementi di un array
  • analisi di codice IA32 generato da gcc

Martedì 25 novembre 2014 (180 min)

• Regole di allineamento e padding per le struct in C
• Strength reduction: esempi di ottimizzazione di basso livello su codice IA32
• Tecniche di ottimizzazione di base: constant folding e (conditional) constant propagation, common subexpression elimination, dead code elimination, copy propagation, loop-invariant code motion
• Inlining: vantaggi, possibili controindicazioni, esempi di impiego
• Register allocation: concetti di base e confronto tra codici compilati da gcc con flag -O0 e -O1

Giovedì 27 novembre 2014 (90 min)

• Sistemi di memoria: astrazione con modello lineare
• Transazioni di lettura e scrittura:
  • trasferimenti da CPU a memoria e viceversa
  • uso del bus della memoria
• Divario tra velocità della CPU e velocità di accesso a memoria: evoluzione negli ultimi decenni
• Località spaziale e temporale: dati e istruzioni
• Cache come memorie veloci per compensare divario tra velocità di processamento e velocità accesso a memoria sfruttando il principio di località
• Trasferimento dati tra memoria e cache a blocchi
• Cache hit e cache miss

Martedì 2 dicembre 2014 (180 min)

• Tipi di cache: con mapping diretto, associativa a k vie, pienamente associativa
• Nozione di working set di un programma
• Tipi di cache miss: cold, conflict, capacity
• Analisi dei cache miss generati da un programma che calcola la somma degli elementi di un array
• Rimpiazzo delle linee di cache: LRU (least recently used)
• Cache miss generati dalla scansione lineare di un array vs. lista collegata
• Ottimizzazione dei cache miss di un programma: caso di studio del prodotto di matrice
• Gerarchie di memoria: registri, cache L1, L2, L3, memoria, disco
• Analisi di costo/dimensione/velocità dei livelli di una memoria gerarchica
• Tempi di latenza tipici nell'accesso a vari tipi di memoria
• Esercizi su programmazione IA32

Giovedì 4 dicembre 2014 (90 min)

• Memoria virtuale e suoi vantaggi: protezione, condivisione, superamento limiti dimensione memoria fisica
• Spazio di indirizzi logico (o virtuale) e spazio di indirizzi fisico
• Mapping tra indirizzi logici e indirizzi fisici
• Realizzazione del mapping: tabella delle pagine

Martedì 9 dicembre 2014 (180 min)

• Bit validità e protezione nella tabella delle pagine
• Caso di studio: Intel Core i7
  • paginazione a 4 livelli spazio di indirizzi virtuale a 48 bit
  • gerarchia di memoria (L1i, L1d, L2, L3, DDR3)
• Misurazione delle prestazioni: tempo e contatori hardware (IPC, CPI, cicli, istruzioni, cache miss)
• Tool di profilazione: perf e gprof
• Legge di Amdahl per il calcolo sequenziale: speedup complessivo di un programma in fuzione dello speedup di una sua parte
• Complementi: programmi misti C/assembly (scrittura di moduli .s e linking con moduli .c)

Giovedì 11 dicembre 2014 (120 min)

• Flusso del controllo normale ed eccezionale
• Eccezioni recuperabili e non recuperabili
• Eccezioni sincrone (interne):
  • Trap: istruzione IA32 INT e chiamate a sistema
  • Fault: page fault memoria virtuale e loro gestione, protection fault (SIGSEGV), divisione per zero
  • Abort: parity error
• Eccezioni asincrone (esterne):
  • interrupt: dispositivi I/O, timer, ecc.
• Tabella delle eccezioni (interrupt vector)
• Cenni alla tabella delle eccezioni IA32
• Gestione dei segnali nei programmi C: signal e gestori di segnali
• Modalità esecuzione CPU: utente (user) e supervisore (kernel)
• Multiprogrammazione e scheduling della CPU
  • Esecuzione sequenziale e concorrente
  • Uso di timer e interrupt per realizzare scheduling time-sharing
  • Scheduling Round-Robin
  • Cenni allo scheduling con priorità

Martedì 16 dicembre 2014 (180 min)

• Context switch
• Chiamate a funzioni di libreria (user mode) vs. chiamate a sistema (supervisor mode)
• Standard POSIX (cenni)
• Gestione dei processi:
  • Code dei processi: ready, waiting
  • Diagramma di stato di un processo: ready, running, waiting
• Ruolo di un sistema operativo
  • Gestione risorse del sistema:
    • memoria (gestione memoria virtuale, paginazione)
    • CPU (gestione processi)
    • dispositivi I/O (astrazione, device driver)
  • Gestione degli utenti
  • Protezione e sicurezza
  • Comunicazione e sincronizzazione fra processi (non trattato nel modulo)
• Allocazione dinamica della memoria
  • Gestione heap: chiamata a sistema POSIX sbrk
  • Realizzazione delle funzioni malloc e free
  • Frammentazione interna ed esterna
  • Blocchi liberi e in uso
  • Liste di blocchi liberi
  • Anatomia di un blocco: header, puntatori ad altri blocchi liberi, payload, allineamento
  • Analisi dello spazio richiesto per un array e per una lista collegata considerando lo spazio usato internamente dall'allocatore

Secondo modulo (SC2)

Martedì 24 Febbraio e Martedi' 3 Marzo 2015 (360 min): Testo di Riferimento W. Stallings "Operating Systems" (capitoli 3 e 4)

• Panoramica del corso e suo inquadramento nell'ambito complessivo degli esami di informatica del corso di laurea
• Processi e Multi processing
• Thread e Multitreading
• Introduzione alle macchine parallele: Tassonomia di Flynn e Sistemi Paralleli
• Introduzione all'architettura di un kernel di SO: Microkernel
• Pthread: esempi di programmazione

Martedì 10 Marzo e Martedi' 17 Marzo 2015 (360 min): Testo di Riferimento W. Stallings "Operating Systems" (capitolo 5) Slide del docente

• Concorrenza e Sincronizzazione
• Mutua Esclusione
• Semafori e Monitor
• Produttore/Consumatore
• Message Passing
• Readers/Writers

Martedì 24 Marzo, Martedi' 31 Marzo 2015 e Martedi' 21 Aprile (360 min): Slide del docente

• Architettura di Internet: Internet service providers, Internet exchange points, architettura a tre livelli.
• Richiami di TCP/IP
• Sockets: architettura e programmazione
• Network Adaptors: dalla applicazione che utilizza i socket all'invio del messaggio sulla rete

Martedì 21 Aprile e Martedi' 28 Aprile, 2015 (360 min): Slide del docente

• Client-server Computing
• Middleware
• Remote Procedure Calls

Martedì 5 Maggio, 12 Maggio, 19 Maggio 2015 (540 min): note del docente, Slide del docente

• Introduzione ai sistemi distribuiti
• dai sistemi concorrenti ai sistemi distribuiti: evoluzione dei modelli di sistema computazionali
• Mutua esclusione: Algoritmo di Dijkstra, Algoritmo del Panettiere, Algoritmo di Ricart-Agrawal

Martedì 26 (180 min): Slide del Docente

• Introduzione alle minacce cyber
• Vulnerability, software bug, exploit
• Attackers, virus, malware, rootkit