Versione Migliorata

1. Tesi di Laurea
Triennale
Laureando:
Massimo Palmisano
Relatore:
Prof. Marco Tessarotto

2. Titolo Tesi:
Confronto delle prestazioni
dell’algoritmo di Dijkstra su
Sistema Operativo Linux in
modalità utente e
modalità kernel

3. Modalità Utente e
Modalità Kernel
• Progettazione driver del kernel di Linux che necessiti di
fare una ricerca su un grafo con l’algoritmo di Dijkstra.
• Allo scopo si è realizzata una architettura dove il grafo
viene letto e preparato in user space e poi trasmesso al
driver in kernel space per l’elaborazione.
• I processori moderni operano in due distinte modalità
• Modalità utente
• Modalità kernel
• Implementazione dell’algoritmo di Dijkstra nelle due
modalità

4. Algoritmo di Dijkstra
• Trova il percorso minimo in un grafo orientato
avente pesi non negativi
• Implementazione nella sua versione
“elementare”
• No multithreading

5. Progettazione Lato Utente
• Implementazione modalità utente
• Scrittura di un unico programma
• Lavoro suddiviso in tre processi che interoperano tramite pipe:
• Processo 1: Lettura grafo
• Processo 2: Esecuzione Dijkstra
• Processo 3: Scrivi risultati

6. • Implementazione Modalità kernel
• Porzioni di codice che aumentano le funzionalità del kernel
• aggiunti a runtime
• no ricompilazione dell’intero kernel Linux
• no riavvio del sistema
• aumentano funzionalità del kernel Linux
Modulo Kernel Linux

7. • In kernel mode è buona norma non leggere direttamente da file
• Scrittura di un programma utente
• Legge i dati e li passa al modulo kernel
• Interfaccia character device driver
• System call ioctl
Lettura Grafo in Kernel Mode

8. • Grafo implementato in file di testo
• In formato leggibile dai programmi
• Tre grafi per eseguire i benchmark
• 1.000 nodi
• 10.000 nodi
• 100.000 nodi
• Grafi completamente connessi
Benchmark – I

9. • Benchmark eseguito su due macchine diverse
• Modulo Kernel compilato da GCC
• Programma Utente compilato da Clang e GCC
Benchmark – II

10. Prima Macchina – grafo 1.000 nodi
1
1,1
1,2
1,3
1,4
1,5
1,6
1,7
1,8
1,9
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
TempoEsecuzione(ms)
Numero Test
CPU Intel(R) Xeon(R) CPU E5-2640 0 @ 2.50GHz
Kernel Mode GCC User Mode GCC User Mode Clang

11. 90
100
110
120
130
140
150
160
170
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
TempoEsecuzione(ms)
Numero Test
CPU Intel(R) Xeon(R) CPU E5-2640 0 @ 2.50GHz
Modulo Kernel User Space GCC User Space Clang
Prima Macchina – grafo 10.000 nodi

12. 15000
15500
16000
16500
17000
17500
18000
18500
19000
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
TempoEsecuzione(ms)
Numero Test
CPU Intel(R) Xeon(R) CPU E5-2640 0 @ 2.50GHz
Modulo Kernel Userspace GCC Userspace Clang
Prima Macchina – grafo 100.000 nodi

13. Risultati Benchmark in percentuale
Differenza in percentuale tra il
tempo medio di esecuzione in
user space (GCC 9) e il tempo
medio di esecuzione in Kernel
Space
Differenza in percentuale tra il
tempo medio di esecuzione in
user space (Clang 9) e il tempo
medio di esecuzione in Kernel
Space
Grafo 1.000 nodi 48,37% 55.59%
Grafo 10.000 nodi -7,70% 17,01%
Grafo 100.000 nodi -0,23% 16,88%

14. Commento
Risultati
• Clang 9 produce un codice macchina con
tempi di esecuzione migliori di GCC 9 su CPU
Intel(R) Xeon(R) CPU E5-2640 0 @ 2.50GHz
• Ipotesi della differenza di prestazioni nel
caso del grafo di 1.000 nodi è il diverso modo
di allocare la memoria in modalità kernel
(kvmalloc_node e kvfree) e in modalità
utente (malloc free)
Differenza in percen-
tuale tra il tempo me-
dio di esecuzione in
user space (GCC 9) e il
tempo medio di ese-
cuzione in Kernel
Space
Differenza in percentuale
tra il tempo medio di
ese-cuzione in user
space (Clang 9) e il
tempo medio di
esecuzione in Kernel
Space
1.000 nodi 48,37% 55,59%
10.000 nodi -7,70% 17,01%
100.000 nodi -0,23% 16,88%

15. Seconda Macchina – grafo 1.000 nodi
7,5
8,5
9,5
10,5
11,5
12,5
13,5
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
TempoEsecuzione(ms)
Numero Test
Raspberry PI 3 model B+, ARM Cortex-A53, 1.2 GHz
Kernel module Userspace GCC Userspace CLANG

16. 610
612
614
616
618
620
622
624
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
TempoEsecuzione(ms)
Numero Test
Raspberry PI 3 model B+, ARM Cortex-A53, 1.2 GHz
Kernel module Userspace GCC Userspace CLANG
Seconda Macchina – grafo 10.000 nodi

17. 86000
87000
88000
89000
90000
91000
92000
93000
94000
95000
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
TempoEsecuzione(ms)
Numero Test
Raspberry PI 3 model B+, ARM Cortex-A53, 1.2 GHz
Kernel module Userspace GCC Userspace CLANG
Seconda Macchina – grafo 100.000 nodi

18. Risultati Benchmark in percentuale
Differenza in percentuale tra il
tempo medio di esecuzione in
user space (GCC 9) e il tempo
medio di esecuzione in Kernel
Space
Differenza in percentuale tra il
tempo medio di esecuzione in
user space (Clang 9) e il tempo
medio di esecuzione in Kernel
Space
Grafo 1.000 nodi 13,33% 4,89%
Grafo 10.000 nodi 1,78% 1,63%
Grafo 100.000 nodi 1,54% 1,36%

19. Commento
Risultati
- Compilatori differenti producono codice
macchina aventi tempi di esecuzione simili a
parità di CPU ARM Cortex-A53, 1.2 GHz
- La differenza di prestazioni nel caso del
grafo 1.000 nodi potrebbe essere dovuta al
diverso modo di allocare la memoria in
modalità kernel e in modalità utente
Differenza in percen-
tuale tra il tempo me-
dio di esecuzione in
user space (GCC 6) e il
tempo medio di ese-
cuzione in Kernel
Space
Differenza in percentuale
tra il tempo medio di
ese-cuzione in user
space (Clang 6) e il
tempo medio di
esecuzione in Kernel
Space
1.000 nodi 13,33% 4,89%
10.000 nodi 1,78% 1,63%
100.000 nodi 1,54% 1,36%

20. Conclusioni
• È possibile implementare un device driver che esegua l’algoritmo di Dijkstra, sebbene
le prestazioni in modalità kernel sono in generale non superiori a quelle che si
otterrebbero da un’implementazione in modalità utente
• Prestazioni dipendono da molti fattori
• Architettura del processore
• Condizioni interne del processore (clock dinamico, temperatura, memoria cache)
• Compilatore e livello di ottimizzazione del codice prodotto