SISTEMI OPERATIVI IIN prima prova in itinere

SISTEMI OPERATIVI IIN
prima prova in itinere - 02.03.2006
Nome: __________________
Cognome: __________________
Esercizio 1.
Quattro processi sono caratterizzati dai tempi di arrivo e di utilizzo della CPU indicati in tabella:
Pid
1
2
3
4
tarrivo
0
0
1
2
tCPU
6
5
2
3
Supponendo che i processi siano schedulati secondo gli algoritmi first come first served (FCFS) e
shortest job first (SJF) con prelazione, si determinino:
- i diagrammi di Gantt;
- i tempi di attesa e di ritorno medi;
- il numero di cambi di contesto.
Nel caso due o più processi risultino equivalenti rispetto ai criteri di scelta utilizzati dagli algoritmi di
scheduling, accordare la preferenza al processo con identificatore (Pid) più basso.
Esercizio 2.
Si definisca una classe Java che realizzi una soluzione multithreaded dell’algoritmo di ordinamento
quicksort.
Come noto, l’algoritmo opera in modo ricorsivo partizionando ad ogni passo l’insieme (vettore) di
partenza in due parti, costituite dagli elementi minori e maggiori di un elemento pivot che viene
portato nella posizione che assumerà nell’insieme finale ordinato. L’idea della soluzione
multithreaded è che ad ogni livello della ricorsione, thread differenti possano operare sui due
sottoinsiemi generati dal partizionamento.
Per una possibile traccia della soluzione fare riferimento al pseudo-codice riportato nel retro.
Traccia soluzione Esercizio 2.
In pseudo-codice una possibile struttura della classe soluzione è la seguente:
class QuickSort {
int[] data;
// array da ordinare
int lowerbound;
// limite inferiore dell’array da ordinare
int upperbound;
// limite superiore dell’array da ordinare
// costruttore
public QuickSort (???...???) {
???...???
}
int partition() {
// partiziona l’insieme compreso tra lowebound e upperbound muovendo il pivot
// nella posizione finale del vettore. Ritorna la posizione del pivot nel vettore.
}
void ricorsione {
if ( lowerbound >= upperbound )
return;
int pivotIndex = partition();
// ricorsione sui due insiemi costituiti dagli elementi a sinistra e a destra del pivot
???....???
}
void main(String[] args) {
// inizializzazione dell’array con valori interi random compresi tra 0 e la dimensione
// dell’array stesso. La dimensione dell’array è letta come argomento da linea di
// comando
???...???
/ / stampa array iniziale
???...???
// inizio algoritmo quicksort
???...???
// stampa array ordinato
???...???
// termine del programma
???...???
}
}
Completare le sezioni di codice contrassegnate con ???...??? e ricondurre la sintassi dell’intero
programma a quella Java.
Soluzione
Esercizio 1.
Diagrammi di Gantt:
FCFS
P1
0
P2
6
SJF
P2 P3
0
1
P4
3
P2
6
P3
11
P4
13
P1
10
16
16
Tempi di attesa e di ritorno medi:
FCFS
TA = (TA(P1) + TA(P2) + TA(P3) + TA(P4))/ 4 = (0 + 6 + 10 + 11)/4 = 6.75
TR = (TR(P1) + TR(P2) + TR(P3) + TR(P4))/ 4 = (6 + 11 + 12 + 14)/4 = 10.75
SJF
TA = (TA(P1) + TA(P2) + TA(P3) + TA(P4))/ 4 = (10 + 5 + 0 + 1)/4 = 4
TR = (TR(P1) + TR(P2) + TR(P3) + TR(P4))/ 4 = (16 + 10 + 2 + 4)/4 = 8
Numero cambi di contesto:
FCFS:
Ncs = 3
SJF:
Ncs = 4
Esercizio 2.
package quicksort;
public class QuickSort extends Thread {
private int[] data;
// array to be sorted
private int lowerbound;
// lower bound of the array to be sorted
private int upperbound;
// upper bound of the array to be sorted
public QuickSort (int start, int end, int[] data) {
this.data = data;
this.lowerbound = start;
this.upperbound = end;
}
protected int partition() {
int left = lowerbound-1;
int right = upperbound;
int pivot = data[upperbound];
int tmp;
// partition loop
while ( left < right ) {
do { left++;
} while ( data[left] <= pivot && left < right );
do { right--;
} while ( data[right] > pivot && right > left);
if ( left < right ) {
tmp = data[left];
data[left] = data[right];
data[right] = tmp;
}
}
int pivotIndex = left;
tmp = data[pivotIndex];
data[pivotIndex] = pivot;
data[upperbound] = tmp;
// put the pivot back
return pivotIndex;
}
public void run() {
if ( lowerbound >= upperbound )
return;
int pivotIndex = partition();
// start the "recursive threads"
QuickSort leftThread = new QuickSort(lowerbound, pivotIndex - 1, data);
leftThread.start();
QuickSort rightThread = new QuickSort(pivotIndex + 1, upperbound, data);
rightThread.start();
try {
leftThread.join();
// wait for the child threads
rightThread.join();
}
catch ( InterruptedException ie ) {
System.out.println( "Interrotto durante join" );
}
}
public static void main( String[] args ) {
int arraySize = Integer.parseInt( args[0] );
int[] data = new int[arraySize];
System.out.println("before quicksort the array is: ");
for (int i=0;i<arraySize;i++) {
data[i] = (int)(Math.random()*arraySize);
System.out.print( data[i] + " ");
}
QuickSort qst = new QuickSort(0, arraySize-1, data);
qst.start();
// wait for the quicksort thread to finish
try {
qst.join();
}
catch ( InterruptedException ie ) {
System.out.println( "Interrotto durante join" );
}
System.out.println("\nafter quicksort the array is: ");
for (int i=0;i<arraySize;i++)
System.out.print( data[i] + " ");
System.exit(0);
}
}