Lezioni Anno Accademico 2015/16

scrivete qui idee, riassunti dei concetti espressi, commenti approfondimenti sulle lezioni.

Lezione del 22 settembre 2015

Introduzione al corso di Sistemi Operativi.

concetti

• Hardware vs. Software
• Informatica
• Scienza vs. Tecnologia
• Informazione (vs. Dato)
• Linguaggio
• Elaborazione-Memorizzazione-Comunicazione
• Algoritmo vs. Programma
• Hacker/Hacking (vs. Cracker)
• Maker
• Analogico-Digitale

Lezione del 23 settembre 2015

Storia dei Sistemi.... anche operativi.

concetti

• Architettura a livelli (Layer)
• SO come livello di astrazione (semplificazione, portabilita')
• SO come gestore di risorse (controllo, sicurezza, continuita' di servizio)
• Storia le generazioni: ingranaggi->Valvole termoioniche->Transistor->Circuiti integrati->Microprocessori
• I "ruoli" dell'informatica: ideatore, costruttore, programmatore, operatore, utente
• Multitasking (perche' e' possibile? perche' e quando e' necessario?)
• Interattivita'
• TIme sharing
• Multiuser (multiutente)
• UNIX
• Personal Computer (e i sistemi operativi)

Lezione del 30 settembre 2015

Il materiale per poter replicare l'esperimento sulla portabilità dei compilatori è qui.

Renzo (talk) 09:38, 3 October 2015 (CEST)

Per gli esperimenti con le macchine virtuali:

• il file debian_wheezy_i386_desktop.qcow2 l'ho preso da qui: https://people.debian.org/~aurel32/qemu/i386/.

il comando per kvm è:

 kvm -m 1G -drive file=$(echo debian_wheezy*.qcow2),cache=writeback -monitor stdio

• chi volesse provare debian hurd può scaricare l'immagine: debian-hurd-20150424.img da qui: https://www.debian.org/ports/hurd/hurd-install. Nella pagina è anche indicato come lanciare kvm (io aggiungerei -monitor stdio in fondo per avere la console di qemu-kvm).

Renzo (talk) 09:47, 3 October 2015 (CEST)

concetti

• Conoscenze a breve, medio e lungo termine dell'informatica
• Linguaggio dell'Hardware
• X Virtuale (dove X rappresenta qualsiasi cosa)
• Emulazione/Simulazione
• virtualizzazione senza emulazione
• Cosa e', cosa non e' e dov'e' (realmente) il sistema operativo
• macchine virtuali
• Distribuzione e Ambiente Operativo
• Licenze: differenza fra Software Libero e Open Source

Lezione del 07 ottobre 2015

Ricordo che è in sospeso una domanda: "l'arduino ha un sistema operativo?"

Concetti: ripasso linguaggio C

• Compilatori vs. Interpreti
• Programmi vs. Script
• Le classi di linguaggi di programmazione
• Il "livello" dei linguaggi di programmazione
• Cosa e', cosa non e' il Linguaggio C
• Genesi del linguaggio C: intenzioni degli autori
• Le vere novita' del linguaggio C

concetti: ripasso architettura

• Modelli architetturali: von Neumann vs. Harvard
• Gerarchia di Memoria
• Cache
• Indirizzi Logici, Indirizzi Fisici
• Rilocazione

strumenti utilizzati durante la lezione

• Arduino, hardware e sistema di sviluppo. Nelle distribuzioni debian-like c'e' il pacchetto denominato "Arduino"

 apt-get install arduino

• Una scheda con il solo microcontrollore atmega (nella scheda in aula era un atmega168). Ho tratto ispirazione da questo articolo di tuxgraphics. Non e' necessario fare tutte le fasi iniziali di "software installation" perche' sono tutti software pacchettizzati debian. Se avete installato il pacchetto arduino tutti i cross compiler e lo strumento per caricare il firmware li trovate gia' disponibili.
• Il programma C senza librerie e' il seguente:

typedef unsigned char uint8_t;
typedef unsigned long uint32_t;
typedef unsigned short uint16_t;

int main(void)
{
  *((volatile uint8_t *) 0x2B) = 0x00;
  *((volatile uint8_t *) 0x2A) = 0xFF;

  while (1) {
    volatile uint16_t t;
    for (t=0; t<10000; t++)
      ;
    *((volatile uint8_t *) 0x2B) += 1;
  }
  return(0);
}

per vedere il led lampeggiare occorre collegarlo (con la resistenza di limitazione della corrente) al pin 2 (porta D0) poi al pin 3 (porta D1) etc... (spostate il circuito disegnato alla porta 28 nella pagina sopra citata di tuxgraphics ai pin 2, 3 etc). NB: se volete collegare le porte GPIO o i2c di arduino o di un atmega ad un raspberry PI controllate che la tensione di lavoro dell'arduino/atmega sia 3.3v e NON 5v.

Lezione del 14 ottobre 2015

Nella pagina "esercizi ed esperimenti" ho proposto degli Esercizi di lettura di codice C. Renzo (talk) 15:43, 10 October 2015 (CEST)

temi trattati: ripasso Linguaggio C

• Preprocessori: inclusione, compilazione condizionale macro
• Macro vs. funzioni inline
• Static vs. Extern
• Static vs. Auto
• Register

temi trattati: ripasso Architettura degli Elaboratori

• Bus Indirizzi, Bus Dati, Gerarchie di Bus
• Interrupt (e Trap)
• Mascheramento degli Interrupt
• Gestione nidificata degli interrupt
• DMA (Direct Memory Access)

temi accennati:

• uarm: l'emulatore per il progetto

Lezione del 21 ottobre 2015

(Correzione) Compiti a casa:

• Nella pagina "esercizi ed esperimenti" ho proposto degli Esercizi di lettura di codice C. Sono da provare e commentare. E' possibile proporne di nuovi.
• Provare a installare uarm: l'emulatore per il progetto nei propri sistemi.

argomenti trattati

• vettori, strutture e puntatori in C
• il debugging: gdb
• la funzione _start nei sistemi UNIX like.

Ecco l'esempio di funzione start minimale:

.text
.global _start

_start:
  xor %rbp, %rbp
  popq %rdi
  movq %rsp, %rsi
  andq $~15, %rsp
  call main
  //nuova interfaccia syscall
  mov %rax, %rdi
  mov $231, %rax
  syscall
  //vecchia interfaccia syscall
  //mov %eax, %ebx
  //mov $252, %eax
  //int $0x80

E il sorgente C usato nell'esperimento di debugging:

struct test {
  int a[16];
};

struct test x={{42,73,51}};

int f(struct test t) {
  return t.a[0]+t.a[1]+t.a[2];
}

int main(int argc, char *argv[]) {
  volatile int sum=f(x);
  return argc;
}

Lezione del 28 ottobre 2015

argomenti trattati

• uARM interfaccia
• uARM esecuzione di programmi e debug
• cross-compilazione per uARM
• la libreria libuarm
• analisi della funzione tprint (polling di output)
• debug tramite variabili e funzioni dummy

• _start per ARM:

.global _start
_start:
  sub     lr, lr, lr
  ldr     r0, [sp]
  add     r1, sp, #4
  bl main
  mov R7, #1
  swi 0

ripasso di architettura

• la pipeline del processore
• Struttura del processore: Control Path, Data Path
• CISC vs RISC

Lezione del 4 novembre 2015

argomenti trattati

• Sistemi Real Time
• I sistemi operativi per sistemi multiprocessore (SMP e non SMP)
• gestione nidificata degli Interrupt nidificati
• gli stack del kernel
• programmed I/O (polling) vs interrupt
• dispositivi "memory mapped" e non (come si interfacciano i dispositivi)
• compilazione del kernel

Lezione del 11 novembre 2015

• Visiting Lecturer: Prof. Michael Goldweber: the meaning of our O.S. project.

• Awsome Lecture by Prof. Goldweber and Prof. Davoli! (rd: questo non l'ho scritto io ;-)

Lezione del 18 novembre 2015

Argomenti trattati

• componenti del SO: gestore processi, gestore memoria primaria, gestione memoria secondaria, file system, I/O, protezione, networking
• analisi delle system call delle prime versioni di UNIX (I manuali consultati a lezione sono qui)
• esperimenti con la libreria pthreads. (risponde alla richiesta threads in C and how to use them...)

Esperimento (minimale) di creazione di due thread:

#include <stdio.h>
#include <unistd.h>
#include <pthread.h>

void *thread(void *arg) {
  long n=(long)arg;
  int i;
  for (i=0; i<10; i++)  {
    printf("thread %d %d\n",n,i);
    //usleep(10000);
  }
  return NULL;
}

int main(int argc, char *argv[]) {
  pthread_t t[2];
  pthread_create(&t[0], NULL, thread, (void *)0);
  pthread_create(&t[1], NULL, thread, (void *)1);
  pthread_join(t[0],NULL);
  pthread_join(t[1],NULL);
}

Race condition:

#include <stdio.h>
#include <unistd.h>
#include <pthread.h>

long tot;

void *thread(void *arg) {
  long n=(long)arg;
  int i;
  for (i=0; i<100000000; i++)
    tot  += n;
  return NULL;
}

int main(int argc, char *argv[]) {
  pthread_t t[2];
  pthread_create(&t[0], NULL, thread, (void *)-1);
  pthread_create(&t[1], NULL, thread, (void *)1);
  pthread_join(t[0],NULL);
  pthread_join(t[1],NULL);
  printf("tot = %d\n",tot);
}

Uso di istruzioni atomiche fornite da gcc:

#include <stdio.h>
#include <unistd.h>
#include <pthread.h>

long tot;

void *thread(void *arg) {
  long n=(long)arg;
  int i;
  for (i=0; i<100000000; i++)
    __sync_fetch_and_add (&tot, n);
  return NULL;
}

int main(int argc, char *argv[]) {
  pthread_t t[2];
  pthread_create(&t[0], NULL, thread, (void *)-1);
  pthread_create(&t[1], NULL, thread, (void *)1);
  pthread_join(t[0],NULL);
  pthread_join(t[1],NULL);
  printf("tot = %d\n",tot);
}

Uso di mutex:

#include <stdio.h>
#include <unistd.h>
#include <pthread.h>

long tot;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

void *thread(void *arg) {
  long n=(long)arg;
  int i;
  for (i=0; i<100000000; i++) {
    pthread_mutex_lock(&mutex);
    tot += n;
    pthread_mutex_unlock(&mutex);
  }
  return NULL;
}

int main(int argc, char *argv[]) {
  pthread_t t[2];
  pthread_create(&t[0], NULL, thread, (void *)-1);
  pthread_create(&t[1], NULL, thread, (void *)1);
  pthread_join(t[0],NULL);
  pthread_join(t[1],NULL);
  printf("tot = %d\n",tot);
}

Lezione del 25 novembre 2015

argomenti trattati

• Presentazione della phase0 e phase1 del progetto (v. specifiche)
• Sistemi di versioning: esempi con GIT.

Lezione del 2 dicembre 2015

Argomenti Trattati

• System Call: accesso ai file open/read/write/close

es. copia di file (il terzo parametro è l'ampiezza del buffer)

• System Call: gestione processi fork/execve/wait

CAPITOLI del corso da svolgere

(in italico i temi già trattati o parzialmente trattati)

• Sruttura del SO
• Scheduler
• Gestione risorse (deadlock)
• Gestione memoria centrale (paginazione, segmentazione, memoria virtuale)
• Gestione memoria secondaria
• File system
• Sicurezza

• Strumenti per lo sviluppo, la portabilita' e la collaborazione (make, autotool, versioning)
• System Call POSIX
• Principali librerie (LibC, Pthreads, Socket...)
• Bash (uso avanzato e scripting)
• Python

• uARM
• progetto prima fase
• progetto seconda fase

Argomenti proposti dagli studenti

• System Call's e/o esempi di uso
• Instruction Set & Assembly
• Memoria Centrale, Indirizzamento, Memoria Virtuale, Swapping, Traduzione Indirizzi logici in indirizzi fisici (metodi e circuiteria usata)
• Scheduling dei processi e tipi di Scheduler
• Linguaggi nuovi (esempio: Python)
• Scripting
• Tool di programmazione (make, automake ecc)
• Differenze Linker, Loader ecc
• Crittografia e uso nei sistemi operativi
• Extreme C (esempi di uso (DIsuso) del linguaggio C.

(proposte di argomenti fornite da studenti. Saranno tutti trattati, piu' avanti nel corso).

• Scheduling / Schedulers
• Memory Management / Virtual Memory / Swapping Area
• Replacement Algorithms
• uARM further examination