J'ai peaufiné le code pour réduire le traitement de 30 secondes à moins d'une seconde dans différentes parties de mon programme bash. Je ne parviens pas à comprendre comment la commande time
fonctionne lorsqu'elle indique les variables real
, user
et sys
.
echo " "
echo "Time to build DirsNdxArr from DirsArr $DirsArrCnt elements:"
DirsArrCnt=${#DirsArr[@]}
time for (( i=1; i<$DirsArrCnt; i=i+$DaElementCnt )); do
DirsNdxArr["${DirsArr[$i]}"]=$i
AllItemSizes=$(( $AllItemSizes + ${DirsArr[$(( $i + $ColFileSizes - 1 ))]} ))
done
echo " "
echo "Time to build FilesNdxArr from FilesArr $FilesArrCnt elements:"
FilesArrCnt=${#FilesArr[@]}
time for (( i=0; i<$FilesArrCnt; i=i+$FaElementCnt )); do
FilesNdxArr["${FilesArr[$i]}"]=$i
AllTagSizes=$(( $AllTagSizes + ${FilesArr[$(( $i + $FaColFileSizes ))]} ))
done
Time to build DirsNdxArr from DirsArr 56700 elements:
real 0m0.149s
user 0m0.149s
sys 0m0.000s
Time to build FilesNdxArr from FilesArr 390 elements:
real 0m0.002s
user 0m0.002s
sys 0m0.000s
sys
time indique-t-il zéro?En interprétant la sortie de la commande intégrée time
, on pourrait supposer que le système ne fait rien mais ce n’est sûrement pas ce qui se passe?
ps Je sais que \n
peut être utilisé comme nouvelle ligne de echo
avec le paramètre -e
. Mon habitude est de sacrifier un argument de bord et des arguments marginaux en faveur de la lisibilité.
En résumé, cela signifie simplement que votre programme n'a pas demandé à exécuter de tâches privilégiées. Le processeur n'a donc pas passé de temps en mode privilégié (noyau).
Tout d’abord, vous devez comprendre plusieurs choses pour interpréter correctement le résultat de time
:
time
vous exécutez (car il y en a plusieurs)Il y a deux types de commandes time
. Il y a Shell intégré et il y a /usr/bin/time
. Le shell intégré est celui que vous utilisez et affiche par défaut 3 lignes, real
, user
et sys
. Le manuel de time
mentionne également cette même forme de sortie:
-p, --portability Use the following format string, for conformance with POSIX standard 1003.2: real %e user %U sys %S
Et si vous consultez la section "FORMATAGE DE LA SORTIE", nous avons:
E Elapsed real (wall clock) time used by the process, in [hours:]minutes:seconds. U Total number of CPU-seconds that the process used directly (in user mode), in seconds. S Total number of CPU-seconds used by the system on behalf of the process (in kernel mode), in seconds.
De toutes ces informations, nous pouvons déduire qu'il existe deux modes d'exploitation du processeur: le mode utilisateur et le mode noyau, et que la commande time
indique la durée pendant laquelle le processeur reste dans un mode donné pour faire tout ce que votre programme/application a demandé au processeur. faire.
Bien, nous comprenons donc que la différence est qu’il existe un mode utilisateur et un mode noyau dans lesquels le code peut être exécuté. Nous pouvons déjà comprendre que cela signifie fondamentalement que le programme n'a pas utilisé le mode noyau pour exécuter certaines tâches. Qu'est-ce que cela signifie réellement?
Reportez-vous à ce post :
En mode noyau, le code d'exécution dispose d'un accès complet et illimité au matériel sous-jacent. Il peut exécuter toute instruction de la CPU et référencer toute adresse de mémoire.
Et d'une autre réponse sur le même post:
Le passage du mode utilisateur au mode noyau n’est pas effectué automatiquement par la CPU. La CPU est interrompue par des interruptions (minuteries, clavier, E/S). Lorsque l'interruption se produit, la CPU cesse d'exécuter le programme en cours, passe en mode noyau et exécute le gestionnaire d'interruptions. Ce gestionnaire enregistre l'état de la CPU, effectue ses opérations, le restaure et revient en mode utilisateur.
C’est donc ce que votre sortie signifie: il n’ya pas eu de basculement en mode noyau et la CPU n’a reçu aucune interruption du programme à cet effet. Cela signifie également que votre code n'a rien qui exigerait des privilèges élevés de la part du processeur.
Remarque : ceci devrait probablement être reformulé comme "il n'y avait pas de commutateur long/visible en mode noyau", car allouer de la mémoire avec quelque chose comme malloc()
la fonction en C nécessiterait de passer en mode noyau, mais ce sont des commutateurs microscopiques, qu'il faudrait vraiment étudier avec un débogueur ou une commande strace
.