Struttura, metodi di gestione e configurazione dei dischi rigidi;
Il linguaggio di programmazione C;
Il Sistema Operativo Linux-Fedora installato, con relativo
utilizzo della shell bash attraverso i principali comandi
standard UNIX;
Il protocollo NFS (Network File System);
Sviluppo di programmi in C per la scrittura e la lettura di file da
256 MB su un hard disk remoto;
Test di velocità di NFS riguardo la scrittura e la lettura di
file in un hard disk remoto.
Testing dell’efficienza di una rete composta da 5 macchine collegate tra
loro, analizzando la velocità di trasferimento dei dati tramite operazioni di
lettura e scrittura.
lxmaster01
Gigabit Ethernet
switch cisco
catalyst 6000
Fast Ethernet fullduplex
lxmaster02
lxmaster03
lxmaster04
lxmaster05
Dischi: Un disco è una memoria su cui è possibile eseguire le
operazioni di lettura scrittura e spostamento
Il disco è suddiviso in tracce e settori; un insieme di settori è
chiamato cluster.
Conf. Dischi:
mirror :scrive su 2 dischi gli stessi dati metodo lento ma più sicuro;
stripped:ogni disco contiene meta' dell'informazione, metodo più
veloce in lettura e scrittura ma in caso di rottura di un disco si
perdono tutti i dati;
Raid 5:le informazioni sono suddivise in n-1 dischi e l'n disco
contiene i bit di parità quindi in caso di rottura di un solo disco,
dopo la sostituzione, attraverso il disco di parita e' possibile
ricostruire tutti i file.
File system:
vengono creati durante la formattazione logica di un disco e sono
composti da un insieme di moduli che permettono la scrittura e la
lettura di un disco. Il file system di Windows è il FAT 16,24,32 a
seconda della quantità di bit da cui è costituito, Unix-Linux invece
utilizza principalmente EXT3 che utilizza la tecnologia I-NODE che
contiene un’ area di dati del file e un’area che punta a blocchi
contenente il file(indirizzament singolo) Nell'indirizzamento doppio
l’I-NODE punta a dei blocchi e a loro volta puntano altri blocchi
che conterranno il file.
Il tipo di distribuzione Linux installata è la versione “Fedora 8”.
PRINCIPALI PROCEDURE DI INSTALLAZIONE:
• Configurazione degli hard disk in stripe mode, in modo da ridurre i tempi
di lettura e scrittura, ma perdendo garanzia sulla sicurezza dei dati;
• Suddivisione del disco tra i seguenti file system: root, boot, home, swap;
• Configurazione rete ethernet;
• Scelta e installazione dei pacchetti aggiuntivi del sistema operativo;
non e' stato possibile installare l'ultima versione di Fedora (Fedora 9),
perche' essendo stata rilasciata alla fine di maggio presentava al suo
avvio diversi bug
La shell è uno dei livelli che compongono i sistemi operativi UNIX.
Esegue la read (o lettura) di una linea di comando dallo standard input e
la interpreta secondo uno schema di regole prefissato. In pratica rende
comprensibili alla macchina i comandi che le vengono inviati.
PRINCIPALI COMANDI DELLA SHELL:
ls: visualizza il contenuto di una directory;
cd: cambia la directory di lavoro;
mkdir: crea una nuova directory;
touch: crea un nuovo file;
rm: cancellazione di un file;
chmod: cambia i diritti di lettura,scrittura ed eseguibilità di un file;
more: visualizza il contenuto di un file;
su: cambia utenza;
ps: visualizza i nomi dei processi in esecuzione in una data shell;
reboot: riavvio del sistema;
ssh: prende il controllo di una macchina remota collegata in rete;
find: ricerca di un file nel sistema.
vi nomeprog: apre l'editor vi per scrivere programmi in linguaggio C
Il Network File System è un protocollo sviluppato
inizialmente da Sun Microsystems nel 1984. L'NFS è un
file system che consente ai computer di utilizzare la rete
per accedere ai dischi remoti come fossero dischi locali.
NFS è spesso associato a sistemi Unix, sebbene spesso
sia utilizzato anche da macchine utilizzanti i sistemi
operativi Macintosh e Microsoft Windows.
NFS permette ad n calcolatori che compongono un
sistema distribuito di condividere file, directory od un
intero file system utilizzando il protocollo client-server
Un calcolatore (client) deve richiedere esplicitamente ad
un altro calcolatore (server) del sistema distribuito di
condividere una directory o un file, dichiarando un punto
di montaggio. Una volta effettuato un montaggio un
utente sul calcolatore client accede alla directory
montata in modo assolutamente trasparente, ossia
accede alla directory remota credendo di accedere ad
una directory locale.
NFS si può pensare inoltre come uno strato superiore
del famoso protocollo TCP/IP.
#include <stdio.h>
main()
{
int p,r,l,x,y;
p=0;
l=0;
r=1;
x=0;
y=x;
x=getchar();
while (x==10 | x==32)
{
l=l+1;
if (x==32) r=r+1;
x= getchar();
}
if (x!=EOF)
{
p=p+1;
while (x!=EOF)
{
if (x!=EOF)
{
if (!(x==10 | x==32)&&(y==10 | y==32))
p=p+1;
l=l+1;
if (x==32) r=r+1;
}
y=x;
x=getchar();
}
}
printf("\n i caratteri sono: %d \n ", l);
printf("le parole sono: %d \n ", p);
printf("le righe sono: %d \n ", r);
}
Questo
programma è
stato
l’introduzione al
linguaggio C e al
suo utilizzo. E'
una semplice
funzione che
calcola il numero
di caratteri,
parole, righe
presenti da un
flusso di input
#include<stdio.h>
#include <time.h>
#include <unistd.h>
#include <stdlib.h>
int main(int argc,char *argv[])
{
FILE *pf;
int c;
int sizeb,sizef;
char lett[131072];
#define BILLION 1000000000L;
struct timespec start, stop;
double accum;
sizeb=atoi(argv[2]);
sizef=atoi(argv[3]);
if (sizeb>131072)
{
printf("\n Inserire una dim. max. cluster di 131072 \n");
exit(-1);
}
if (argc<2)
{
printf("\n Inserire dal prompt il nome del file \n");
}
for (c=0;c<argc;c++)
{
printf("\n parametro %d : %s \n",c , argv[c]);
}
pf=fopen(argv[1],"w");
if (pf==NULL)
{
printf("\n il file non e' stato aperto \n");
exit(-1);
}
else
{
printf("\n file aperto con successo \n");
for (c=0;c<131072;c++)
lett[c]='a';
if( clock_gettime( CLOCK_REALTIME, &start) == -1 ) {
perror( "clock gettime" );
return EXIT_FAILURE;
}
for(c=0;c<sizef;c=c+sizeb)
fwrite(&lett,sizeb,1,pf);
fclose(pf);
if( clock_gettime( CLOCK_REALTIME, &stop) == -1 ) {
perror( "clock gettime" );
return EXIT_FAILURE;
}
accum = ( stop.tv_sec - start.tv_sec )
+ (double)( stop.tv_nsec - start.tv_nsec )
/ (double)BILLION;
printf("\n file scritto con successo \n");
printf("\n tempo impiegato = %lf\n", accum);
}
}
#include<stdio.h>
#include <time.h>
#include <unistd.h>
#include <stdlib.h>
int main(int argc,char *argv[])
{
FILE *pf;
int c;
int sizeb,sizef;
char lett[131072];
struct timespec start, stop;
#define BILLION 1000000000L;
double accum;
sizeb=atoi(argv[2]);
sizef=atoi(argv[3]);
int dim;
if (argc<2)
{
printf("\n Inserire dal prompt il nome del file
\n");
exit(-1);
}
for (c=0;c<argc;c++)
{
printf("\n parametro %d : %s \n",c ,
argv[c]);
}
pf=fopen(argv[1],"r");
if (pf==NULL)
{
printf("\n il file non e' stato aperto \n");
exit(-1);
}
else
{
printf("\n file aperto con successo \n");
fseek(pf,0, SEEK_END );
dim=ftell(pf);
if ((sizeb>dim)||(sizef>dim)||(sizeb<=0)||(sizef<=0))
{
printf("\n Inserire una dim. max di %d e maggiore di 0 \n",dim);
exit(-1);
}
else
fseek(pf,0,SEEK_SET);
if( clock_gettime( CLOCK_REALTIME, &start) == -1 ) {
perror( "clock gettime" );
return EXIT_FAILURE;
}
for(c=0;c<sizef;c=c+sizeb)
{
fread(&lett,sizeb,1,pf);
}
fclose(pf);
if( clock_gettime( CLOCK_REALTIME, &stop) == -1 ) {
perror( "clock gettime" );
return EXIT_FAILURE;
}
accum = ( stop.tv_sec - start.tv_sec )
+ (double)( stop.tv_nsec - start.tv_nsec )
/ (double)BILLION;
printf("\n lettura effettuata ");
printf("\n tempo impiegato = %lf\n", accum);
}
}
Test di velocità in scrittura e lettura su disco remoto con variazione
di Block Size e numero di macchine.
1 CLIENT
blocchi
1024
2048
4096
8192
16384
32768
65536
131072
scrittura
tempo
35.31
35.14
35.29
35.12
34.52
34.78
35.28
35.34
velocita
7.25
7.29
7.25
7.29
7.42
7.36
7.26
7.24
blocchi
1024
2048
4096
8192
16384
32768
65536
131072
lettura
tempo
34.33
33.92
33.98
33.93
34.29
34.22
34.33
34.14
velocita
7.46
7.55
7.54
7.54
7.47
7.48
7.46
7.5
2 CLIENTS
blocchi
1024
2048
4096
8192
16384
32768
65536
131072
scrittura
tempo
98.6
99.46
97.93
98.31
102.03
83.52
103.55
133.85
blocchi
1024
2048
4096
8192
16384
32768
65536
131072
lettura
tempo
72.98
68.91
77.23
67.31
39.55
37.83
37.79
34.62
velocita
3.51
3.71
3.32
3.8
6.47
6.76
6.77
7.4
blocchi
1024
2048
4096
8192
16384
32768
65536
131072
lettura
tempo
91.49
62.29
67.48
49.81
50.85
50.44
52.51
41.3
velocita
2.8
4.11
3.79
5.14
5.03
5.08
4.87
6.2
velocita
2.6
2.57
2.61
2.6
2.51
3.07
1.87
1.91
3 CLIENTS
blocchi
1024
2048
4096
8192
16384
32768
65536
131072
scrittura
tempo
164.15
90.41
237.22
167.2
138.03
249.23
149.56
177.84
velocita
1.56
2.83
1.08
1.53
1.85
1.03
1.71
1.44
lettura e scrittura 1 client
7.5
velocita (MB/sec)
7.4
7.3
lettura
scrittura
7.2
7.1
7
1024
2048
4096
8192
16384
block size (byte)
32768
65536
131072
lettura e scrittura 2 clients
8
7
velocita (MB/sec)
6
5
4
lettura
scrittura
3
2
1
0
1024
2048
4096
8192
16384
block size (byte)
32768
65536
131072
lettura e scrittura 3 clients
7
6
velocita (MB/sec)
5
4
lettura
scrittura
3
2
1
0
1024
2048
4096
8192
16384
block size (byte)
32768
65536
131072
Analizzando i dati delle tabelle si nota che la lettura tende
ad aumentare di velocità con l’ aumentare del block size
mentre la scrittura aumenta di velocità fino a raggiungere
un valore di picco e poi tende a rallentare.
Quindi sfruttando i dati raccolti si potranno ottimizzare le
operazioni di lettura e scrittura da 1 a 3 macchine con un
disco in remoto impostando il block size che massimizza
tali operazioni
Block size scelti:
Con 1 client:16384 per la scrittura e 2048 per la lettura
Con 2 client:32768 per la scrittura e 131072 per la lettura
Con 3 client:2048 per la scrittura e 131072 per la lettura
Non è stato possibile raccogliere dati con 4 macchine in
quanto una ha presentato problemi hardware durante
l’esercitazione.