Ubuntu-fr

pnprog

Défragmenteur naïf

Bonjour à tous !
J'ai réalisé un petit script bash qui permet de défragmenter ses dossiers sur une partition ext3.
En fait, il ne défragmente pas, il duplique/supprime/recrée les fichiers qui sont fragmentés. Autrement dit, il aide ext3 à "s'auto-défragmenter à l'usage" et c'est pour ça que je l'appelle défragmenteur naïf.

Il utilise la commande filefrag pour fonctionner. Filefrag permet de tester la fragmentation d'un fichier. Donc le script ne déplace que les fichiers fragmentés.

Voici le code du script:

#!/bin/bash
#défragmenteur naïf
#auteur: pnprog AT no-log DOT org
#fichier: n_defrag.sh
#version 0.3
#ce script est proposé sous licence GPL2 (General Public License)



########################################
############ initialisation ############
########################################

#nom d'essais par defaut
nb_max_try=10
#le fichier qui servira de buffer
buffer=$(pwd)/buffer
#le fichier de "journalisation"
current_operation=$(pwd)/current

#variables pour les statistiques
nb_fragmented_files=0
nb_files=0
nb_error_files=0
nb_undefragmentable_files=0
fbmo_sum_before=0
fbmo_sum_after=0


########################################
###### affichage du mode d'emploi ######
########################################

display_usage_and_quit()
{
	echo Usage:
	echo -e "\t$0 [-t try] directory"
	echo -e "\tAnalyse and defragment files in directory."
	echo -e "\tThe -t option indcates how many times the programme can try"
	echo -e "\tto defragment a file. Default value is 10."
	echo ""
	echo -e "\t$0 -r"
	echo -e "\tUse this option in case an analyse has been interrupted."
	exit 1
}


########################################
###### vérification des arguments ######
########################################

#répertoire à défragmenter
rep_start=""

#l'utilisateur peut lancer le mode recovery, si l'analyse a été intérompue
if let "$#==1"
then
	if [ "$1" = "-r" ] ;
	then
		#### mode recovery ####
		#on récupere le fichier en cours de l'analyse, si intérompue
		file=$(cat "$current_operation" 2>>/dev/null)
		interrupted=$?
		if [ "$interrupted" = "0" ]
		then
			#recréation du fichier
			cp -p "$buffer" "$file" 2>>/dev/null
		fi
		echo "Recovery done."
		exit 0
	else
		##### mode normal ####
		rep_start="$1"
	fi
fi

#l'utilisateur peut spécifier le nombre d'essais
if let "$#==3"
then
	if [ "$1" = "-t" ] && [ "$2" -ge 0 ] ;
	then
		#### l'utilisateur spécifie le nombre d'essais ####
		rep_start="$3"
		nb_max_try="$2"
	else
		display_usage_and_quit
	fi
fi

#nombre d'argument incohérent (0, 2, 4 ou plus)
if [ "$rep_start" = "" ]
then
	display_usage_and_quit
fi

########################################
#### vérification de filefrag et bc ####
########################################

#http://www.debian.org/doc/developers-reference/ch-best-pkging-practices.fr.html
which filefrag >> /dev/null
if [ "$?" = "1" ]
then
	echo You must install filefrag.
fi

which bc >> /dev/null
if [ "$?" = "1" ]
then
	echo You must install bc.
fi


########################################
#### vérification des droits (root) ####
########################################

UID_ROOT=0
if [ "$UID" -ne "$UID_ROOT" ]
then
	echo You must be root to run filefrag.
	exit 1
fi



########################################
############### fonctions ##############
########################################

function count_fragments
	{
	#4 cas possibles
		#chaine vide, filefrag a causé une erreur
		#file: 1 extent found
		#file: X extents found
		#file: X extents found, perfection would be 1 extent
	file=$1
	result=$(sudo filefrag "$file" 2>> /dev/null)
	if [ "$result" = "" ]
	then
		echo "-1"
	else
		result=${result#"$file":}
		result=${result%% extent*}
		echo $result
	fi
	}

function file_size
	{
	file=$1
	size=$(du -k "$file")
	size=${size%%"$file"}
	echo $size
	}

function frag_by_mo
	{
	file=$1
	nb_fragments=$(count_fragments "$file")
	size=$(file_size "$file")
	if let "$size>0"
	then
		echo "scale=2 ; 1024 * ( $nb_fragments - 1 ) / $size " | bc
	else
		echo 0
	fi
	}

one_more_analyse()
{
	file=$1
	#on compte le nombre de fragments
	nb_fragments=$(count_fragments "$file")
	if let "$nb_fragments>1"
	then
		assemble "$file"
	else
		echo -n " ok"
	fi
}

assemble()
{
	#recollage du fichier
	file=$1
	#on augmente le compteur du nombre de tentatives
	nb_try=$(($nb_try + 1))
	if let "nb_try<=nb_max_try"
	then
		#il reste des tentatives possibles
		#on copie donc le fichier dans le buffer
		cp -p "$file" "$buffer"
		#création du journal
		$(echo "$(pwd)/$file" > "$current_operation")
		#suppression du fichier original
		rm "$file"
		#recréation du fichier original grâce au buffer
		cp -p "$buffer" "$file"
		#suppression du journal
		$(rm "$current_operation")
		#suppression du buffer
		rm "$buffer"
		#remarque, on pourrait se contenter de déplacer le buffer
		#plutôt qu'en faire une copie
		#mais en cas de coupure, on garde ainsi l'orginal
		echo -n "."
		
		#on relance une alnalyse sur le fichier (récursivement)
		one_more_analyse "$1"
	else
		#on a dépassé le nombre de tentatives autorisé
		nb_undefragmentable_files=$(($nb_undefragmentable_files + 1))
		fbmo=$(frag_by_mo "$file") && fbmo_sum_after=$(echo "scale=2 ; $fbmo_sum_after + $fbmo " | bc)
		echo -n " "
		echo -n $(count_fragments "$file")
	fi
}

analyse()
{
	file=$1
	#on compte le nombre de fragments
	nb_fragments=$(count_fragments "$file")
	if let "$nb_fragments>1"
	then
		#le fichier est fragmenté
		#mise à jour des statistiques
		nb_fragmented_files=$(($nb_fragmented_files + 1))
		fbmo=$(frag_by_mo "$file") && fbmo_sum_before=$(echo "scale=2 ; $fbmo_sum_before + $fbmo " | bc)
		nb_try=0
		echo -n "$(pwd)/$file" $(count_fragments "$file") ""
		#on essaye de le recoller
		assemble "$file"
		echo ""
	elif [ "$nb_fragments" = "-1" ]
	then
		#erreur générée par filefrag
		echo Erreur: filefrag can not analyse $(pwd)/$file
		nb_error_files=$(($nb_error_files + 1))
	fi
}



analyse_only()
{
	file=$1
	#on compte le nombre de fragments
	nb_fragments=$(count_fragments "$file")
	if let "$nb_fragments>1"
	then
		#le fichier est fragmenté
		#mise à jour des statistiques
		nb_fragmented_files=$(($nb_fragmented_files + 1))
		fbm=$(frag_by_mo "$file")
		sum_fbm=$(echo "scale=2 ; $sum_fbm + $fbm " | bc)
		
		
		#echo -n "$(pwd)/$file" $(count_fragments "$file") ""

	elif [ "$nb_fragments" = "-1" ]
	then
		#erreur générée par filefrag
		#echo Erreur: filefrag can not analyse $(pwd)/$file
		nb_error_files=$(($nb_error_files + 1))
	fi
}



########################################
########## fonction principale #########
########################################

#parcours récursif des répertoires
scan()
{

	rep=$1
	#on tente de se placer dans le répertoire
	cd "$rep"
	cd_ok=$?

	if [ "$cd_ok" = "0" ]
	then
		#on est dans le répertoire
		#on liste les fichiers
		for file in *
		do
			#on evite les liens symboliques, les périfériques etc.
			if test ! -h "$file"
			then
				#si c'est un fichier, on l'analyse
				#si c'est un répertoire, on l'explore
				if test -f "$file"
				then
					nb_files=$(($nb_files + 1))
					#lancement de l'analyse
					analyse "$file"
				else
					if test -d "$file"
					then
						#exploration récursive
						scan "$file"
					fi
				fi
			fi
		done
		#le répertoire a été analysé
		#on revient au répertoire parent
		cd ..
	else
		echo Erreur: ne peut ouvrir le répertoire $(pwd)/$rep
	fi
}

#lancement
scan "$rep_start"

#affichage des statistiques
echo "Analyse results for $rep_start"

echo -n $nb_files files
if let "$nb_files>0"
then
	echo -n ": "$(echo "scale=2 ; $fbmo_sum_after / $nb_files " | bc)" f/Mo"
	echo " (before: "$(echo "scale=2 ; $fbmo_sum_before / $nb_files " | bc)" f/Mo)"
else
	echo ""
fi


if let "$nb_error_files>0"
then
	echo $nb_error_files files have not been analysed
fi



echo -n $nb_fragmented_files files were fragmented
if let "$nb_fragmented_files>0"
then
	echo ": "$(echo "scale=2 ; $fbmo_sum_before / $nb_fragmented_files " | bc)" f/Mo"
else
	echo ""
fi


echo -n $nb_undefragmentable_files files are still fragmented
if let "$nb_undefragmentable_files>0"
then
	echo ": "$(echo "scale=2 ; $fbmo_sum_after / $nb_undefragmentable_files " | bc)" f/Mo"
else
	echo ""
fi

#echo $nb_undefragmentable_files files are still fragmented: $(echo "scale=2 ; $fbmo_sum_after / $nb_undefragmentable_files " | bc) f/Mo

exit 0

Dernière modification par pnprog (Le 27/05/2008, à 17:25)

pnprog

Re : Défragmenteur naïf

Pour s'en servir, il faut recopier le code dans un fichier, le rendre exécutable et le lancer (dans une console) en mode administrateur en donnant en paramètre un dossier.

sudo ./n_defrag.sh ~/Documents/

Deux options sont disponibles:

-t: qui permet de spécifier le nombre d'essais pour chaque fichier. En effet, même après recopie, un fichier peut parfois être encore fragmenté. Le script recommence alors plusieurs fois jusqu'à défragmentation complète, ou jusqu'à ce que la limite -t soit atteinte. Par défaut, t vaut 10.
Utiliser -t 0 fait que le script analyse uniquement la fragmentation du dossier, et ne cherche pas à le défragmenter. Utile pour avoir une idée de la fragmentation du dossier sans prendre de risques.

sudo ./n_defrag.sh -t 20 ~/Documents/

-r: lance un mode de récupération. Si une précédente défragmentation a été interrompue, il est TRES FORTEMENT recommandé de s'en servir. Vous pourriez sinon perdre le fichier qui était en cours d'analyse.

sudo ./n_defrag.sh -r

Pendant l'analyse, vous verrez défiler les noms des fichiers fragmentés, et les tentatives successives pour les défragmenter:

/home/user/Document/monfichier1.doc 4 ... ok
/home/user/Document/monfichier2.doc 12 .......... 5

Le premier étant un fichier défragmenté avec succes, le second étant un fichier qui n'a pas pu être défragmenté. Le premier chiffre indique le nombre de fragments avant la tentative de fragmentation. Le second chiffre indique le nombre de fragment après, ok voulant dire un seul fragment. Il peut arriver que le second chiffre soit plus important que le premier, autrement dit, le fichier est alors plus fragmenté qu'au début, même si vous aviez beaucoup de place libre sur votre disque. Je ne sais pas à quoi cela est dû.

A la fin de la défragmentation, le programme affiche un petit résumé:

sudo ./n_defrag.sh ~/Documents/
[...]
Analyse results for ~/Documents/
30570 files: 0 f/Mo (before: .01 f/Mo)
2 files have not been analysed
43 files were fragmented: 9.60 f/Mo
28 files are still fragmented: 1.87 f/Mo

Les fichiers non analysés sont liés à un bug de filefrag qui plante en lisant les fichiers commençant par "-" comme par exemple "-monfichier.doc". Le créateur a dû se planter dans la manière de parser l'option "-s" du programme.

L'unité f/Mo signifie en quelque sorte "fragmentation par Mega Octet". Plus précisément, si un fichier de taille X Mo est fragmenté en N morceaux, alors la fragmentation par Mega Octet se calcule ainsi:

fragmentation par Mega Octet = (N-1)/X

Et par conséquent, un fichier non fragmenté a 0 f/Mo. Les futures versions de ce script devront permettre de fixer un seuil minimal de f/Mo au dessous duquel le script n'essaye pas de défragmenter le fichier. En effet, qu'un fichier de 700Mo (une image iso par exemple) soit fragmenté en 4 morceaux (0,004 f/Mo) n'est pas vraiment problématique, car le temps de déplacement de la tête de lecture du disque entre les morceaux sera certainement négligeable devant le temps de lecture complet des données. Donc inutile d'essayer de le défragmenter, opération lourde vu la taille du fichier, et qui peut tout simplement être impossible si il n'y a pas sur la partition 700Mo d'espace libre contigu. Par contre, on aura tout intérêt à défragmenter un fichier de 5Mo fragmenté en plus de 20 morceaux (3,8 f/Mo).

J'ai fait de mon mieux pour éviter les mauvaises surprises, il y a plein de vérifications partout. Cependant, je n'ai pas l'habitude du bash, et je suis sûr que beaucoup d'améliorations pourraient être faites, ou bien certaines parties du code ré-écrites proprement.

Je l'ai lancé sur mon répertoire racine et je n'ai pas eu de problèmes, mais je ne peux pas garantir à tout le monde que ce sera pareil, donc prudence. Prudence en particulier si vous voulez l'utiliser sur les données vitales du système (le noyau dans le dossier /boot par exemple). Le risque étant un plantage du système (si le système cherche à accéder à des fichiers fragmentés en cours de défragmentation) et dans le pire des cas, l'impossibilité de redémarrer le système (si le système a planté au mauvais moment). Utilisez le paramètre -t 0 dans un premier temps pour vérifier si ces données ont réellement besoin d'être défragmentées.

Je l'ai aussi testé sur des partions FAT et NTFS, et ça n'a pas posé pas de problèmes non plus. Donc apparemment ce script peut être utilisé pour défragmenter vos partitions Windows.

Les fichiers souvent fragmentés sont par exemple:
* Les fichiers téléchargés, quand plusieurs fichiers sont téléchargés en même temps depuis des logiciels qui ne réservent pas la place avant le début du téléchargement. Ça me semble être le cas d'Amule et Firefox entre autre (à confirmer).
* Les fichiers sur des partitions partagées avec Windows. Donc les clefs USB et disques externes.

Dernière modification par pnprog (Le 30/05/2008, à 09:58)

Ferod

Re : Défragmenteur naïf

Salut

Il se trouve sur quels dépot le paquet de filefrag parce que je le trouve pas... J'ai pourtant les main, universe, restricted et multiverse d'activé. Je suis sous Ubtuntu v8.04.

sebastien@Daneel:520-Script$ sudo apt-get install filefrag
[sudo] password for sebastien: 
Lecture des listes de paquets... Fait
Construction de l'arbre des dépendances       
Lecture des informations d'état... Fait
E: Impossible de trouver le paquet filefrag

OK. Je viens de voir qu'il est installé par défaut...

Dernière modification par Ferod (Le 16/05/2008, à 16:04)

---

"When I was in the military, they gave me a medal for killing
two men, and a descharge for loving one !" Leonard Matlovich

Ferod

Re : Défragmenteur naïf

Bon maintenant que ça a tourné je peux faire quelques remarques !

Analyse results for Vidéos
4260 files
0 files have not been analysed
101 files were fragmented
28 files are still fragmented

Je l'ai lancé avec le nombre d'essais par défaut donc 10.

Mes suggestions :
-> remplacer "0 files have not been analysed" par "all files analysed !" ça fait moins mal à la tête...
-> créer un fichier log par défaut. Tout ce qui s'écrit sur le terminal ça peut être intéressant à voir surtout en cas de plantage.
-> rajouter le temps pris pour l'exécution.

Voilà !

---

"When I was in the military, they gave me a medal for killing
two men, and a descharge for loving one !" Leonard Matlovich

Brunod

Re : Défragmenteur naïf

Salut,
Un peu HS mais je dois dire que je suis très partisan d'un défrag Linux !
Cela me permettrait de faire le ménage sur mes disques partagés en Fat et ntfs sans plus devoir utiliser un pc Win pour cela.
Donc bravo pour l'initiative !
BD

---

Windows est un système d'exploitation de l'homme par l'ordinateur. Linux, c'est le contraire...
39 pc linux convertis

sakul

Re : Défragmenteur naïf

oui mais là si j'ai bien compris, c'est un défrag pour ext3 et je doute que tu ai installé winwin sur du ext3 ....:rolleyes:

---

commandes de bases ||  Debian testing 64bit - xfce / Intel-Core-2 Quad @ 2.33GHz / 9600 GT

pnprog

Re : Défragmenteur naïf

Il se trouve sur quels dépot le paquet de filefrag parce que je le trouve pas... J'ai pourtant les main, universe, restricted et multiverse d'activé. Je suis sous Ubtuntu v8.04.

OK. Je viens de voir qu'il est installé par défaut...

Autant pour moi, je croyais que c'était un paquet que j'avais installé. En fait c'est une commande.
J'ai commencé à écrire ce script avant ma migration à Hardy Heron (au cas ou je casse tout mon système en faisant les tests, que ça ne soit pas trop grâve !) et je ne me souvenais pas.

J'ai  corrigé mon post, merci !

pnprog

Re : Défragmenteur naïf

Mes suggestions :
-> remplacer "0 files have not been analysed" par "all files analysed !" ça fait moins mal à la tête...

Ou même ne pas l'afficher du tout dans ce cas ! En fait, les fichiers commençants par "-" doivent être assez rares, une chance que j'en avais pour me rendre compte du bug de filefrag.
Il y a peut-être d'autres types fichiers qui le font planter, mais ça m'étonnerait.
Je pourrais écrire une rustine pour contourner le problème, par exemple renommer le fichier avant analyse, mais ça ne serait pas très propre. J'enverrai un email à l'auteur pour lui signaler plutôt.

-> créer un fichier log par défaut. Tout ce qui s'écrit sur le terminal ça peut être intéressant à voir surtout en cas de plantage.

Le log est une bonne idée. En fait, l'idéal serait de récupérer le nombre de fragments des fichiers non défragmentés. J'ai remarqué que certains de mes fichiers sont vraiment très fragmentés (fichiers audios de quelques Mo fragmentés en 20 ou 30 morceaux par exemple).
Certains résistent à mon script même si je passe le nombre d'essais à 100 ou plus ! le nombre de fragments oscille alors autour de la même valeur.
Mais pour l'instant j'ai beaucoup de mal avec bash, je ne sais pas comment faire une simple fonction qui retournerait un résultat (le nombre de fragments). C'est vraiment "bizarre" comme langage :-)

-> rajouter le temps pris pour l'exécution.

Oui, je commencerai par ça, ça ne doit pas être difficile.

Voilà !

Merci d'avoir testé, je suis un peu rassuré en voyant que ça ne cause pas de dégâts. On ne sait jamais :-)

pnprog

Re : Défragmenteur naïf

Un peu HS mais je dois dire que je suis très partisan d'un défrag Linux !
Cela me permettrait de faire le ménage sur mes disques partagés en Fat et ntfs sans plus devoir utiliser un pc Win pour cela.

oui mais là si j'ai bien compris, c'est un défrag pour ext3 et je doute que tu ai installé winwin sur du ext3 ....roll

En fait je ne sais pas comment le FAT ou le NTFS est géré par Linux. Est-ce que ces deux formats de partition fragmentent aussi sous Linux ? auquel cas la fragmentation est inhérente à ces formats. Ou bien est-ce qu'ils ne formatent que sous Windows ? auquel cas la fragmentation vient de la manière dont l'OS travaille avec ces types de partitions.

Je n'y ai pas pensé, mais je peux me servir de ma clef USB pour tester avec le FAT ou le NTFS. Je le ferai demain.

NicoA380

Re : Défragmenteur naïf

Je testerai à l'occasion

pnprog

Re : Défragmenteur naïf

J'ai fait quelques modifications dans le script:

* Affichage du nombre de fragments avant et après.
* Gestion des partions FAT et NTFS.
* Un peu de nettoyage du code pour gagner en clarté.

Dans le détail:

La première version ne plantait pas pour les partions FAT ou NTFS, mais le script ne remarquais pas les fichiers fragmentés, donc il ne touchait pas à ces partitions.

J'ai rajouté une fonction qui retourne le nombre de fragment, ça permet de l'afficher et de voir clairement l'amélioration apportée par le script, ou pas. En effet, certains de mes fichiers sont absolument indéframentables, bien que mon disque possède plus de 20 Go de mémoire libre. Plusieurs passage successif du script n'arrange en rien la situation, je me demande pourquoi.

Avec cette fonction, le code est un peu plus clair. Mais surtout, je vais pouvoir m'en servir pour rendre le script plus "intelligent". Par exemple, faire une copie du fichier fragmenté, et si la copie est moins fragmentée, alors remplacer l'original par la copie, sinon, supprimer la copie et recommencer...

Voila voila...

figaro

Re : Défragmenteur naïf

A lire pour comprendre la fragmentation :

PS le nouveau format ext4 augmentera la taille réservée à la première écriture par rapport à ext3 et diminuera encore plus le risque de fragmentation sur les partitions Linux.

---

Le blog de figaro (astuces diverses et tutos Samba pour débutants)
Le blog de cep (astuces Linux avancées)
Debian Lenny 6.0.1, Ubuntu 10.04.2, Ubuntu Remix 9.10, Ubuntu Netbook 10.04

ogaby

Re : Défragmenteur naïf

Je n'ai pas tester ce programme mais j'ai déjà fait des defrags "à la main": en gros déplacé le fichier sur une autre partition et le remettre à l'emplacement d'origine.

Un jour, j'ai voulu défragmenter mon noyau.... et je ne pouvais plus démarrer.

Défragmentez uniquement vos documents mais pas le système.

pnprog

Re : Défragmenteur naïf

A lire pour comprendre la fragmentation :

Cela confirme ce que je pensais déjà. Ainsi, si un jour Windows supporte ext3 ou un autre format de partition libre, il le fera fragmenter...
Je m'en suis aussi rendu compte en utilisant le script sur une partition ntfs: tout les fichiers étaient défragmentés et répartis sur l'ensemble du disque avec de l'espace entre chacun. On peut le voir en utilisant le défragmenteur de Windows.
J'ai alors forcé Windows à le redéfragmenter à nouveau, et il a compacté tout les fichiers ensembles au début du disques, donc sans laisser d'espace entre. C'est une autre stratégie: rassembler tout les fichiers au même endroits, et au début du disques doit aussi diminuer le temps d'acces au fichiers, la tête de lecture du disque se déplace moins. Par contre, quand la taille de certains fichiers augmente, ils sont automatiquement fragmentés.

pnprog

Re : Défragmenteur naïf

Je n'ai pas tester ce programme mais j'ai déjà fait des defrags "à la main": en gros déplacé le fichier sur une autre partition et le remettre à l'emplacement d'origine.
Un jour, j'ai voulu défragmenter mon noyau.... et je ne pouvais plus démarrer.
Défragmentez uniquement vos documents mais pas le système.

J'ai déjà lancé le script sur l'ensemble de mon disque (donc noyau inclus), sans rencontrer de problèmes.
Cela dit, le script ne déplace un fichier QUE s'il est fragmenté, ce qui n'était peut-être pas le cas du noyau. Ou est situé le noyau sur la partition ?

Autre chose, lors de défragmentations à la main avec cp, n'oubliez pas d'utiliser l'option -p qui préserve par défaut les attributs mode, ownership et timestamps.

cp -p fichier copie

ogaby

Re : Défragmenteur naïf

le noyau se trouve dans boot/
avec les fichiers initrd.img-2.6.22-14-generic et vmlinuz-2.6.22-14-generic

Si tu souhaites essayer, sois prudent. Fais une copie de ces 2 fichiers et modifie ton grub pour pouvoir les lancer en cas de pépins.

pnprog

Re : Défragmenteur naïf

J'ai regardé dans mon dossier /boot mais les fichiers qui s'y trouvent ne sont pas fragmentés. Impossible de dire s'ils l'étaient avant par contre. Et s'ils ne l'étaient pas, alors c'est normal que la défragmentation n'ait pas posée de problèmes, vu que le script n'aura fait que survoler ce dossier sans rien toucher.

Dans tout les cas, je vais rajouter un avertissement dans le mode d'emploi.
Si des casse-cous (ou plutôt des casse-systèmes) ayant leurs noyaux fragmentés veulent essayer...

Dernière modification par pnprog (Le 27/05/2008, à 18:48)

pnprog

Re : Défragmenteur naïf

Mise à jour du script:

* Correction de petits bugs (qui étaient sans dangers) dans la lecture des résultats de filefrag.
* Mise à jour du rapport de fragmentation.

En particulier, j'ai imaginé une nouvelle mesure de la fragmentation que je trouve plus claire que les habituels pourcentages.
En effet, dire que sous Linux, la fragmentation ne dépasse pas 3% n'est pas très clair, que signifie ces 3% ?
* 3% des fichiers sont fragmentés ?
* Les fichiers fragmentés representent 3% du disque ? (je crois que c'est plutôt celle-ci)

Bref, le script calcule quelque chose que j'appele la fragmentation par Mega Octet: f/Mo
Si un fichier de taille X Mo est fragmenté en N morceaux, alors la fragmentation par Mega Octet se calcule ainsi:

fragmentation par Mega Octet = (N-1)/X

Et par conséquent, un fichier non fragmenté a 0 f/Mo.
Les futures versions de ce script devront permettre de fixer un seuil minimal de f/Mo au dessous duquel le script n'essaye pas de défragmenter le fichier.
En effet, qu'un fichier de 700 Mo (une image iso par exemple) soit fragmenté en 4 morceaux (0,004 f/Mo) n'est pas vraiment problématique, car le temps de déplacement de la tête de lecture du disque entre les morceaux sera certainement négligeable devant le temps de lecture complet des données.
Donc inutile d'essayer de le défragmenter, opération lourde vu la taille du fichier, et qui peut tout simplement être impossible si il n'y a pas sur la partition 700Mo d'espace libre contigu.
Par contre, on aura tout intérêt à défragmenter un fichier de 5 Mo fragmenté en plus de 20 morceaux (3,8 f/Mo).

Pour une valeur par défaut pour cette limitte, je penche pour 1 f/Mo ou 0.5 f/Mo, qu'en pensez vous ?

Voici ce que ça donne pour l'avoir lancé sur mon répertoire /var/

Analyse results for /var/
9797 files: 1.42 f/Mo (before: 2.12 f/Mo)
359 files were fragmented: 58.07 f/Mo
231 files are still fragmented: 60.56 f/Mo

Bref, on peut voir que la fragmentation a globalement baissé, mais les fichiers restant sont toujours aussi fragmentés.
J'ai eu l'impression que seuls les fichiers les plus lourds se retrouvaient plus fragmentés qu'avant, et que les fichiers légers étaient correctement défragmentés.
Si c'est effectivement le cas, alors c'est plutôt bon pour le système.
Il faudrait que le programme retienne la fragmentation moyenne des ces fichiers particulier avant défragmentation pour comparaison... peut-être dans une prochaine version.

En tout cas, il faudra attendre un peu avant de voir arriver d'autres options: je dois d'abords apprendre à me servir de getopt pour ne pas pondre une usine à gaz...

uboops

Re : Défragmenteur naïf

Hello,
Merci pour ce script utile, qui fonctionne très bien (sur ext3, le seul que j'ai testé pour le moment) .

code pour visualiser la fragmentation:
sudo bash n_defrag.sh -t 0 /home/hardy

code pour defragmenter:
sudo bash n_defrag.sh -t 20 /home/hardy

Analyse results for /home/hardy
3253 files: 0 f/Mo (before: .03 f/Mo)
4 files were fragmented: 30.33 f/Mo
0 files are still fragmented

J'ai fait ca aussi sur la racine / , c'est très long (1h05 mais pour 138047 files: .06 f/Mo (before: .43 f/Mo) ) , et il y a quelques erreurs, mais c'est normal sur la racine /.

Dernière modification par uboops (Le 28/05/2008, à 10:57)

---

“Au lieu de faire que ce qui fût juste fût fort, on a fait que ce qui fût fort fût juste.” (Blaise Pascal).

Ferod

Re : Défragmenteur naïf

Hello

J'ai pas retesté encore la nouvelle version mais j'avais une petite idée d'amélioration. C'était de ne déplacer et de défragementer que les fichiers en dessous d'une certaine taille qu'on pourrait spécifier en argument dans la commande d'exécution du script.

---

"When I was in the military, they gave me a medal for killing
two men, and a descharge for loving one !" Leonard Matlovich

roger64

Re : Défragmenteur naïf

Bonjour

Je ne suis pas le phœnix des hôtes de ces bois, alors je patine rien que pour utiliser ton script.
Comme tu peux voir, j'ai fait quelques essais :

roger@roger-laptop:~$ sudo n_defrag.sh /home/roger/imageslinux/tux
[sudo] password for roger:
sudo: n_defrag.sh: command not found
roger@roger-laptop:~$ sudo cream n_defrag.sh /home/roger/imageslinux/tux
2 fichiers à éditer
roger@roger-laptop:~$ sudo cream n_defrag.sh -t2 /home/roger/imageslinux/tux
VIM - Vi IMproved 7.1 (2007 May 12, compiled Oct  5 2007 00:50:42)
Trop d'arguments d'édition: "-t2"
Plus d'info avec: "vim -h"
roger@roger-laptop:~$ sudo cream n_defrag.sh -t0 /home/roger/imageslinux/tux
VIM - Vi IMproved 7.1 (2007 May 12, compiled Oct  5 2007 00:50:42)
Trop d'arguments d'édition: "-t0"
Plus d'info avec: "vim -h"
roger@roger-laptop:~$ sudo n_defrag.sh -t2 ~/imageslinux/tux
sudo: n_defrag.sh: command not found
roger@roger-laptop:~$

Peux-tu donner un mode d'emploi pour débutant ? (j'ai débuté il y a tellement longtemps que je suis revenu au point de départ). J'ai copié le texte de ton script dans un fichier texte (j'utilise cream comme éditeur), je l'ai baptisé n_defrag.sh et je l'ai rendu exécutable. Mais apparemment, j'ai des problèmes pour le lancer...

Merci de ta commisération et bravo pour ce projet

---

Les écrits de Richard O'Monroy

sakul

Re : Défragmenteur naïf

il faut donner l'autorisation d'execution au fichier.

(chmod +x )

---

commandes de bases ||  Debian testing 64bit - xfce / Intel-Core-2 Quad @ 2.33GHz / 9600 GT

roger64

Re : Défragmenteur naïf

je l'avais fait.

Nautilus. Clic droit. Propriétés, onglet permissions, cocher la case "autoriser l'eécution du fichier comme un programme"...
maintenant, je ne sais pas comment nommer ce fichier ni que faire de l'extension sh .

SVP j'ai besoin de point sur le i.

Dernière modification par roger64 (Le 29/05/2008, à 14:48)

---

Les écrits de Richard O'Monroy

uboops

Re : Défragmenteur naïf

Bonjour,
Pour info, au cas ou, on ne sait jamais, il ne faut copier dans ton fichier n_defrag.sh qu'à partir de la ligne :

#!/bin/bash
#défragmenteur naïf
#auteur: pnprog AT no-log DOT org
#fichier: n_defrag.sh
.....
exit 0

#!/bin/bash    doit être ta 1ère ligne du fichier script.

Dernière modification par uboops (Le 29/05/2008, à 14:50)

---

“Au lieu de faire que ce qui fût juste fût fort, on a fait que ce qui fût fort fût juste.” (Blaise Pascal).

roger64

Re : Défragmenteur naïf

Merci. C'est bien ce que j'avais fait.

Bon, j'ai réussi, il fallait que j'écrive

sudo bash n_defrag.sh  /dossier

et non

sudo n_defrag.sh /dossier

Le diable est dans les détails...:)
Bon, maintenant, il va falloir que je trouve quelque chose de fragmenté parce que j'avais tout défragmenté il y a quelques jours, mais ça c'est un autre problème..:lol:

Je vais m'interesser au NTFS  Parce que là, oui; il en reste des fragments.

Cette technique est astucieuse. Il me semble, qu'en dehors du risque de la panne de courant, elle est assez sûre. La naiveté a du bon.

Dernière modification par roger64 (Le 29/05/2008, à 15:27)

---

Les écrits de Richard O'Monroy