IFT2010
Structures de données
TP3
Nicola Grenon GREN3077303
jeudi le trente mars deux mille six
Voici le tableau des résultats demandés.
Dans chaque case résultat:
• le premier chiffre est l'espace nécessaire en terme de nombre de CD (le plancher donc)
• le second est le nombre réel de CD utilisés dans ce cas de figure
• le pourcentage représente le taux d'efficacité, à savoir le nombre de CD utilisé par rapport au nombre total de CD (complets) nécessaire dans le meilleur des cas.
Nombre de fichiers
1-50k non-trié
1-50k trié
200-700k non-trié
200-700k trié
10 0,2 / 1
100%
0,2 / 1 100%
7,4 / 9 88,9%
7,4 / 9 88,9%
100 3,4 / 4
100%
3,4 / 4 100%
66,6 / 80 83,8%
/ 77 87,0%
1000 35,7 / 37 97,3%
35,7 / 36 100%
645,4 / 772 83,7%
/ 710 90,8%
10000 355,5 / 361 98,6%
355,5 / 356 100%
6460,8 / 7675 84,2%
/ 7052 91,6%
100000 3566,3 / 3615 98,7%
3566,3 / 3567 100%
64 280,0 / 76 628 83,9%
/ 70 102 91,7%
1000000 35 668,6 / 36140 98,7%
35 668,6 / 35669 100%
642 961,6 / 765 589 84,0%
/ 700 351 91,8%
L'heuristique du WorstFit, sur un ensemble aléatoire de valeurs représentant une faible portion du segment de stockage (ici moins de 8% de chaque disque) fonctionne relativement bien au départ avec dans notre test une note presque parfaite (efficacité tendant vers 98,7% ici). On voit parcontre qu'on peut l'améliorer à 100% (dans notre test) avec des données triées.
Ceci s'explique par le fait que l'on va systématiquement essayer de placer le cas le plus problématique, à savoir le plus gros fichier) dans les espaces disponibles au départ pour utiliser tous les petits fichiers qui s'insèrent bien dans les espaces restants ensuite, ce qui est bien plus facile (par facile je veux dire que la probabilité de minimiser l'espace perdu est augmentée). Ça ne nous garanti pas une efficacité (telle que je l'ai définie) de 100%, mais la probabilité de ne pas l'obtenir est de plus en plus faible à mesure que l'échantillon grossit.
Pour ce qui est de l'efficacité du WorstFit sur des valeurs représentant une forte portion du segment de stockage (ici de 29% à 100% de chaque disque) fonctionne beaucoup moins bien. On note une eficacité tournant autour des 84%, donc une perte nette de 16% d'espace resté inutilisé. Le fait de trier nos données au préalable e va pas garantir un résultat parfait, mais au moins on tend alors vers une efficacité de 92%, soit 8% de perte et donc on a diminué de moitié l'espace inutilisé.
L'explication du phénomène est la même que précédemment,.
Ajoutons pour conclure que l'heuristique du WorstFit s'applique nettement mieux à des éléments
dont la taille est relativement petite et que dans tous les cas, il est clair que le tri préalable des
données donne des résultats meilleurs.
/******************************************************************************
* Fichier Disque.java *
* *
* Auteur: Nicola Grenon (UdeM: GREN30077303) nicola.grenon@umontreal.ca *
* (code d'usager: grenonni) *
* *
* IFT2010 H06 TP3 *
* *
* Classe repésentant un disque (CD) virtuel pouvant stocker plus ou * * moins de fichiers de taille diverses. Taille par défaut de 700 et on gère *
* uniqement les valeurs entières. * ******************************************************************************/
/* Importations */
import java.util.*; // pour Vector
/* La classe Disque -- Implémente comparable */
public class Disque implements Comparable {
private int libre; // taille du disque (espace total) private Vector fichiers; // tailles des fichiers ajoutés
// Constructeur (taille fournie) public Disque(int taille) {
libre = taille; // Initialisation de l'espace libre fichiers = new Vector(); // Init. d'une liste vide de fichiers }
// Constructeur (taille par défaut) public Disque() {
this(700000);
}
// Méthode d'accès à la liste des tailles des fichiers.
private String getListe() { String txt="";
int fin = fichiers.size();
for (int i=0; i < fin; i++) // Pour tous les fichiers du vecteur txt += " " + ((Integer) fichiers.get(i)).intValue(); // Sort la taille
return txt;
}
// Méthode d'ajout d'un fichier au disque: retourne un booléan notant si ok public boolean ajout(int taille) {
if (taille > libre) // Pas assez d'espace libre return false;
else {
libre -= taille; // On déduit de l'espace libre fichiers.add(new Integer(taille)); // On note la taille
return true;
} }
// toString // Pour afficher le disque et son contenu public String toString() {
return fichiers.size() + " " + libre + " :" + getListe();
}
// Implémentation de Comparable // Sera utilisé par le Arrays.sort public int compareTo(Object obj) { // ... et le PriorityQueue dans return ((Disque) obj).libre - libre; // ... archiveDisques.
} // Note: Ordre naturel inversé!
}
/******************************************************************************
* Fichier archiveDisques.java *
* *
* Auteur: Nicola Grenon (UdeM: GREN30077303) nicola.grenon@umontreal.ca *
* (code d'usager: grenonni) *
* *
* IFT2010 H06 TP3 *
* *
* Classe utilisant la classe Dsique pour démontrer l'utilisation de * * l'heuristique du WorstFit à partir de tailles fournies en paramètre lors *
* de l'appel initial. *
******************************************************************************/
/* Importations */
import java.util.*; // pour PriorityQueue et StringTokenizer import java.io.*; // pour BufferedReader
/* La classe archiveDisques -- Contient un main */
class archiveDisques {
// Méthode statique pour lire les données en StdIn (d'un coup) public static StringTokenizer lire() throws IOException {
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
return new StringTokenizer(in.readLine());
}
// Méthode statique pour l'affichage des disques en ordre.
public static void afficher(PriorityQueue pq) {
Disque[] liste = (Disque[]) pq.toArray(new Disque[0]); // On trie les disques.
Arrays.sort(liste);
for (int i = 0; i < liste.length; i++) // On affiche la liste System.out.println(liste[i]);
}
// Main
public static void main(String[] args) {
// Constantes:
final int TAILLE_DISQUE = 700000;
final int NB_MAX_AFFICHAGE = 99;
// Déclaration/Initialisation des variables:
PriorityQueue disques = new PriorityQueue(); // Monceau pour stocker les disques.
long tailleTotale = 0; // Compteur global de taille des fichiers.
int nombreFichiers = 0, // Compteur du nombre de fichiers reçus.
unFichier; // Taille du fichier en traitement.
Disque unDisque = new Disque(TAILLE_DISQUE); // Disque en utilisation.
StringTokenizer nombres; // La liste des tailles des fichiers.
disques.add(unDisque); // On met un premier disque dans le monceau
// Récupération des tailles de fichier sur le StdIn try {
nombres = lire();
}
catch (IOException e) { // Données illisibles sur le StdIn System.out.println("Incapable d'interpréter les tailles des fichiers!");
nombres = new StringTokenizer("");
}
// Boucle principale (pour le classement) while (nombres.hasMoreTokens()) {
try {
unFichier = Integer.parseInt(nombres.nextToken()); // Fichier suivant
unDisque = (Disque) disques.poll(); // On sort le disque le moins plein tailleTotale += unFichier; // On note l'espace total utilisé
if (!unDisque.ajout(unFichier)) { // Si pas assez d'espace sur ce disque Disque nouveauDisque = new Disque(TAILLE_DISQUE); // ... créer un nouveau disque
nouveauDisque.ajout(unFichier); // ... y ajouter le fichier disques.add(nouveauDisque); // ... et stocker le disque.
}
disques.add(unDisque); // Re-stocker le disque sorti.
} catch (Exception e) {}; // Au cas où n'était pas un nombre }
// Résultats
long tot = 10*tailleTotale/TAILLE_DISQUE;
System.out.println("taille totale : " + 0.1*tot); // Espace total utilisé System.out.println("nombre de disques : " + disques.size()); // Nombre total de disques
// Affichage des disques et de leur contenu s'il y en a pas trop if (nombreFichiers <= NB_MAX_AFFICHAGE) afficher(disques);
} }
