Ubuntu-fr

fnux

Affichage du temps passé et barre de progression en bash.

Bonjour,

Je me suis fait un script en bash qui compile un programme, et qui n’affiche rien dans la console pendant le make car j’ai volontairement redirigé ses sorties de la façon suivante :

make clean >/dev/null 2>&1 
make >/dev/null 2>&1

Cependant, suivant l’environnement (le type de hardware et la version de l’OS), ce script peut durer de 3 à 8 minutes et sans affichage..., ça peut sembler long.

Et j’ai d’autres scripts de tests qui peuvent durer jusqu’à 9 heures qui pourraient aussi en bénéficier car là, c'est vraiment très long !

Aussi, après avoir bien cherché sur la toile (sans trouver de solution vraiment appropriée pour être adaptable) j’aimerai afficher:

    - sur une ligne le temps passé depuis le lancement du script en heures, minutes et secondes,
    - et sur la ligne en dessous une barre de progression en mode caractère sur 80 signes du type "nnn% : #####--------------------------------"

pour obtenir un résultat idéal comme ci-dessous:

Srcipt elapsed time      : xx h - yy m -  zz s
Script execution   nnn%  : ####-------------------------------------------

Malheureusement, je n’ai aucune idée de comment m’y prendre car le problème majeur est que je ne maîtrise pas le temps d'exécution qui est variable en fonction soit du script, soit de l'environnement (et/ou des deux) d'ou la difficulté d'utiliser une boucle (for).

Merci d’avance de vos suggestions.

Dernière modification par fnux (Le 24/05/2026, à 03:09)

---

N'engage pas un débat lors d'un dîner car celui qui n'a pas faim aura le dernier mot. - R. Whately

RaphaelG

Re : Affichage du temps passé et barre de progression en bash.

Je ne sais pas répondre à ta question mais ta manière de faire m'inspire une autre question :
Si ta compilation ne se passe pas bien, comment le sais tu ? et surtout comment corriges tu le problème étant donné que tous les messages pouvant aider à une correction sont envoyés aux oubliettes ?
Il vaudrait mieux renvoyer la standard output et la standard error vers un "vrai" fichier consultable à la fin du make.

Watael

Re : Affichage du temps passé et barre de progression en bash.

salut,

je rejoins RaphaelG : tu devrais redirger vers un log.

afaik, une barre de progression n'est réalisable que lorsqu'on connait le terme du process en cours.
c'est faisable sur un morceau de musique, ou, fictivement, sur un nombre de fichiers à copier...
mais là, le calcul de la puissance du processeur rapportée à la capacité mémoire, etc, etc (je ne m'y suis jamais intéressé), va encore ralentir le make
dansl e cas de traitement long, j'ouvre un autre terminal, et/ou je regarde le log pour voir si ça progresse.

le temps d'exécution, lui, est probablement donné par ps :
tu mets le make en arrière plan, tu récupères son PID, et tu le passes à ps en le configurant pour que l'output sorte uniquement le temps d'exécution
il ne sera surement pas donné de façon lisible par un humain, il faudra faire quelques calculs pour lire j h:m:s

---

Connected \o/
Welcome to sHell. · eval is evil.

fnux

Re : Affichage du temps passé et barre de progression en bash.

Bonsoir RaphaelG

Je ne sais pas répondre à ta question mais ta manière de faire m'inspire une autre question :
Si ta compilation ne se passe pas bien, comment le sais tu ? et surtout comment corriges tu le problème étant donné que tous les messages pouvant aider à une correction sont envoyés aux oubliettes ?
Il vaudrait mieux renvoyer la standard output et la standard error vers un "vrai" fichier consultable à la fin du make.

Pour tester tout simplement si la compilation (ou autre job) a réussi, à la fin du script (de compilation ou autre), je teste simplement la présence du fichier attendu.

Et comme je sais d'avance quelles peuvent être les éventuelles erreurs, dans le cas très précis de mes différents scripts, je n'ai pas besoin de fichier de log.

Mais ta remarque est parfaitement justifiée pour une utilisation plus générale de ce genre de fonction.

Merci de ton retour.

Cheers.

Dernière modification par fnux (Le 24/05/2026, à 03:51)

---

N'engage pas un débat lors d'un dîner car celui qui n'a pas faim aura le dernier mot. - R. Whately

Watael

Re : Affichage du temps passé et barre de progression en bash.

je teste simplement la présence du fichier attendu.

quand une commande échoue, elle doit retourner un code d'erreur supérieur à 0.

---

Connected \o/
Welcome to sHell. · eval is evil.

fnux

Re : Affichage du temps passé et barre de progression en bash.

Salut Watael,

salut,

je rejoins RaphaelG : tu devrais redirger vers un log.

Comme répondu à RapahelG, sa remarque est parfaitement justifiée dans le cadre d'une utilisation générale, mais dans mon cas, je n'en ai pas besoin.

afaik, une barre de progression n'est réalisable que lorsqu'on connait le terme du process en cours.
c'est faisable sur un morceau de musique, ou, fictivement, sur un nombre de fichiers à copier...
mais là, le calcul de la puissance du processeur rapportée à la capacité mémoire, etc, etc (je ne m'y suis jamais intéressé), va encore ralentir le make
dansl e cas de traitement long, j'ouvre un autre terminal, et/ou je regarde le log pour voir si ça progresse.

Effectivement le problème majeur est de ne pas connaître "à priori" le temps d'exécution du (des) script(s) pour lequel je veux afficher ces informations de temps d'exécution et de progression

Néanmoins, je peux "tricher" en utilisant une variable (dynamiquement modifiable pour chaque script) dans une boucle (for ou while) qui sez base sur un nombre de secondes déjà connu par les exécutions précédentes, mais ce ne sera jamais très juste en raison du changement de l'environnement (hard et soft).

le temps d'exécution, lui, est probablement donné par ps :
tu mets le make en arrière plan, tu récupères son PID, et tu le passes à ps en le configurant pour que l'output sorte uniquement le temps d'exécution
il ne sera surement pas donné de façon lisible par un humain, il faudra faire quelques calculs pour lire j h:m:s

Pour les calculs des H, M et S, tu m'as déjà aidé il y a quelques jours et je t'en remercie encore.

Pour le reste, je pense simplement tester la fin de l'exécution du script avec son PID pour sortir d'une boucle infinie et rendre la main au système.

Merci de ton intervention.

Cheers.

---

N'engage pas un débat lors d'un dîner car celui qui n'a pas faim aura le dernier mot. - R. Whately

fnux

Re : Affichage du temps passé et barre de progression en bash.

je teste simplement la présence du fichier attendu.

quand une commande échoue, elle doit retourner un code d'erreur supérieur à 0.

Dans le cas de la compilation qui échoue, le script qui la lance se termine simplement en affichant qu'il n'a pas trouvé le fichier exécutable attendu, mais lui même (le script) s'est exécuté sans erreur.

Donc, ce n'est pas la solution que je pense utiliser.

Merci encore de tes suggestions.

Cheers.

---

N'engage pas un débat lors d'un dîner car celui qui n'a pas faim aura le dernier mot. - R. Whately

Watael

Re : Affichage du temps passé et barre de progression en bash.

le script doit retourner le résultat des commandes qu'il exécute
le make ne doit pas être exécuté si le make clean a échoué.
et si le make échoue, alors le script doit aussi faire état de l'échec

un script doit retourner le code d'erreur de la commande en échec, en précisant la commande qui a échoué, bien sûr.

false; st=$?; ((st)) && { >&2 echo "erreur: false: $st"; exit $st;}

---

Connected \o/
Welcome to sHell. · eval is evil.

GR 34

Re : Affichage du temps passé et barre de progression en bash.

Bonjour,

Personnellement je me tournerais vers une solution qui utilise soit Zenity soit Yad...

Avec Zénith :

#!/bin/bash

start=$(date +%s)

(
    echo 0
    echo "# Nettoyage..."
    make clean >/dev/null 2>&1

    echo 50
    echo "# Compilation..."
    make >/dev/null 2>&1

    echo 100
    echo "# Terminé"
) | zenity --progress \
           --title="Compilation" \
           --text="Initialisation..." \
           --percentage=0 \
           --auto-close

end=$(date +%s)
zenity --info --text="Durée totale : $((end - start)) secondes"

Pas testé, il y a peut-être des erreurs... C’est juste pour  l’idée.

---

Karantez-vro...  Breizhad on ha lorc'h ennon !
«Les animaux sont mes amis. Et je ne mange pas mes amis.» George Bernard Shaw
https://www.l214.com/
L’avenir est la chose la plus incertaine qu’il soit ! Le passé c’est de l'avenir déjà réalisé !

geole

Re : Affichage du temps passé et barre de progression en bash.

Bonjour.
Pour connaitre le temps passé et la consommation processeur de la commande

make xxxxx

Il suffit de mettre le mot time devant la commande.

time make xxxxx

Dernière modification par geole (Le 24/05/2026, à 10:48)

---

Les écrans de l'installateur 26.04 https://doc.ubuntu-fr.org/tutoriel/inst … _subiquity

Les partitions EXT4 des disques externes => https://forum.ubuntu-fr.org/viewtopic.p … #p22697248

Watael

Re : Affichage du temps passé et barre de progression en bash.

time ne s'actualise pas pendant le processus; il donne le résultat à la fin.

---

Connected \o/
Welcome to sHell. · eval is evil.

steph810

Re : Affichage du temps passé et barre de progression en bash.

Bonjour,
déterrage essayer ceci:

#!/bin/bash
# ─────────────────────────────────────────────────────────────
#  Usage :
#    ./pacman_progress.sh ./mon_script.sh
#    ./pacman_progress.sh -s apt update        # silencieux
#    ./pacman_progress.sh -l ./script.sh       # log
#    ./pacman_progress.sh -sl apt update       # silencieux + log
# ─────────────────────────────────────────────────────────────
PACMAN_OPEN="ᗧ"
PACMAN_CLOSE="ᗤ"
PACMAN_WIDTH=38

_format_time() {
    local t=$1
    printf "%02d h - %02d m - %02d s" \
        $((t / 3600)) $(((t % 3600) / 60)) $((t % 60))
}

_show_progress() {
    local pid=$1
    local start=$SECONDS
    local frame=0
    local pos=0
    tput civis
    while kill -0 "$pid" 2>/dev/null; do
        local elapsed=$((SECONDS - start))
        local mouth
        ((frame % 2 == 0)) && mouth="$PACMAN_OPEN" || mouth="$PACMAN_CLOSE"
        local col=$((pos % (PACMAN_WIDTH * 2)))
        ((col > PACMAN_WIDTH)) && col=$((PACMAN_WIDTH * 2 - col))
        local corridor=""
        for ((i = 0; i < PACMAN_WIDTH; i++)); do
            if ((i == col)); then
                corridor+="$mouth"
            elif ((i > col)); then
                corridor+="·"
            else
                corridor+=" "
            fi
        done
        tput sc
        #tput cup $(($(tput lines) - 2)) 0
        printf "\033[K  ⏱   Temps écoulé   : \033[1;33m%s\033[0m" \
            "$(_format_time $elapsed)"
        #tput cup $(($(tput lines) - 1)) 0
        printf "\033[K  %s  [ \033[1;33m%s\033[0m ]" "$mouth" "$corridor"
        tput rc
        ((frame++))
        ((pos++))
        sleep 0.2
    done
    local total=$((SECONDS - start))
    #tput cup $(($(tput lines) - 2)) 0
    printf "\033[K  ⏱   Temps écoulé   : \033[1;32m%s\033[0m\n" \
        "$(_format_time $total)"
    printf "\033[K  ᗧ·· Terminé ··· durée réelle : %d secondes\n" "$total"
    tput cnorm
}

SILENT=0
LOG=0
while [[ "$1" == -* ]]; do
    [[ "$1" == *s* ]] && SILENT=1
    [[ "$1" == *l* ]] && LOG=1
    shift
done

if [[ -z "$1" ]]; then
    echo "Usage : $0 [-s] [-l] [-sl] <commande> [args...]"
    echo "  -s   silencieux (cache l'output)"
    echo "  -l   log dans /tmp/<commande>_<date>.log"
    echo "  -sl  silencieux + log"
    exit 1
fi

LOGFILE="/tmp/$(basename "$1")_$(date +%Y%m%d_%H%M%S).log"

if ((SILENT)) && ((LOG)); then
    "$@" >"$LOGFILE" 2>&1 &
elif ((SILENT)); then
    "$@" >/dev/null 2>&1 &
elif ((LOG)); then
    "$@" 2>&1 | tee "$LOGFILE" &
else
    "$@" &
fi
JOB_PID=$!

_show_progress "$JOB_PID"

wait "$JOB_PID"
STATUS=$?

echo ""
if ((STATUS == 0)); then
    printf "  \033[1;32m✔  Succès !\033[0m\n"
    ((LOG)) && printf "  \033[0;37mLog : %s\033[0m\n" "$LOGFILE"
else
    printf "  \033[1;31m✘  Échec (code retour : %d)\033[0m\n" "$STATUS" >&2
    if ((LOG)); then
        printf "  \033[1;31m── Log d'erreur : %s ──\033[0m\n" "$LOGFILE" >&2
        cat "$LOGFILE" >&2
    fi
fi
echo ""
exit $STATUS

peut teste en décommentant les ligne #tput mais ca prend plus de place fonctionne pas sur les script intéractifs...

Dernière modification par steph810 (Le 24/05/2026, à 15:38)

krodelabestiole

Re : Affichage du temps passé et barre de progression en bash.

perso je teste si pv est installé pour afficher une barre de progression :
https://packages.debian.org/fr/sid/pv
par ex. : https://gitlab.com/crachecode/docker-la … =heads#L29

mais c'est probablement une méthode de fainéant ^^

(et comme certains l'ont relevé, je ne suis par contre pas sûr du tout que ce soit faisable pour de la compilation !)

Dernière modification par krodelabestiole (Le 24/05/2026, à 17:26)

---

nouveau forum ubuntu-fr on en parle là : refonte du site / nouveau design
profil - sujets récurrents - sources du site

RaphaelG

Re : Affichage du temps passé et barre de progression en bash.

J'y vais de ma proposition.
J'ai d'abord créé une tâche censée être très longues à s'accomplir.

barredeprogression$ cat long-job.sh 
#!/usr/bin/bash

thisCmd=${0#*/}

usage() {
    echo Usage:
    echo "  $thisCmd -h # print this help"
    echo "  $thisCmd NUMBER # wait NUMBER of second"
    echo -e "\tNUMBER is a positive integer."
    exit $1
}

if [ $# != 1 ]
then usage 1
fi
if [ $1 = "-h" ]
then usage 0
fi
if [[ ! $1 =~ ^[1-9][0-9]*$ ]]
then usage 1
fi

# Here we are: The big job !
sleep $1
exit
barredeprogression$ 

Comme vous pouvez le voir, c'est une appli qui n'est pas bavarde, qui ne fait pas grand chose mais qui peut travailler longtemps.
Il suffit de la lancer avec comme argument un nombre de seconde suffisamment grand.

Maintenant le lanceur et sa barre de progression :

barredeprogression$ cat launcher-progress-bar.sh
#!/bin/sh

running=N
period=5  # to personalize according the context

# launch the long job in background
echo start
./long-job.sh 30 & # of course, the ampersand (&) is very important
bgpid=$! # The process id of the long job

# While the long job is running, print an '*'
while true
do
    running=$(ps -efw | awk -v pid=$bgpid '
        $2 == pid { print "Y"; exit }
        ')
    if [ "$running" = "Y" ]
    then
        echo -n "*"
        sleep $period
        running=N
    else break
    fi
done

# The long job is no more running
echo stop
barredeprogression$ 

Watael

Re : Affichage du temps passé et barre de progression en bash.

running=$(ps h -p $bgpid -o time)

---

Connected \o/
Welcome to sHell. · eval is evil.

RaphaelG

Re : Affichage du temps passé et barre de progression en bash.

C'est vrai, Watael a raison. "ps -efw" est overkill par rapport à ce que je veux faire. J'aurais du de moi même virer les options f et w.
Mais avec l'option -p, j'ai pu simplifier mon script et me passer de awk.

barredeprogression$ cat launcher-progress-bar2.sh
#!/bin/sh

period=5  # to personalize according the context

# launch the long job in background
echo start
./long-job.sh 30 &
bgpid=$! # The process id of the long job

# While the long job is running, print an '*'
while ps h -p $bgpid -o pid > /dev/null
do
    echo -n "*"
    sleep $period
done

# The long job is no more running
echo stop
barredeprogression$

Merci Watael.

fnux

Re : Affichage du temps passé et barre de progression en bash.

Bonjour GR 34,

Bonjour,

Personnellement je me tournerais vers une solution qui utilise soit Zenity soit Yad...

Merci de cette suggestion, mais pour l'instant je me borne au mode caractère en console sans "chichi".

Ce sera très certainement pour plus tard quand j'aurais le temps de m'attarder sur Zenity.

Merci.

Cheers.

---

N'engage pas un débat lors d'un dîner car celui qui n'a pas faim aura le dernier mot. - R. Whately

fnux

Re : Affichage du temps passé et barre de progression en bash.

Bonjour geole,

Bonjour.
Pour connaitre le temps passé et la consommation processeur de la commande

make xxxxx

Il suffit de mettre le mot time devant la commande.

time make xxxxx

Merci pour ton intervention, mais malheureusement tu te trompes un peu.

Si la commande [time] affiche bien par exemple (pour une tâche donnée) :

time ./my-script.sh"

real	7m1.070s
user	5m54.104s
sys	1m3.803s

elle n'affiche pas la consommation du CPU.

De plus, ses résultats ne sont pas exploitables (même en leur appliquant des calculs) pour ce que je veux faire à savoir une barre de progression.

Merci quand même.

Cheers.

---

N'engage pas un débat lors d'un dîner car celui qui n'a pas faim aura le dernier mot. - R. Whately

fnux

Re : Affichage du temps passé et barre de progression en bash.

Bonjour krodelabestiole,

perso je teste si pv est installé pour afficher une barre de progression :
https://packages.debian.org/fr/sid/pv
par ex. : https://gitlab.com/crachecode/docker-la … =heads#L29

mais c'est probablement une méthode de fainéant ^^

(et comme certains l'ont relevé, je ne suis par contre pas sûr du tout que ce soit faisable pour de la compilation !)

Merci de cette suggestion, mais comme tu le mentionnes bien, encore faut-il que pv soit installé, ce qui n'est pas mon cas sur aucune de mes 6 machines : 2 iMac27 i7 x86_64, 1 MacMini Server i7 x86-64, 1 MacBook Core2 Duo x86-64, 1 NoteBook Asus ROG 750 i7 x86-64 et mon petit dernier préféré 1 Raspberry Pi 500+ aarch64, tous fonctionnant sous Linux (en attendant avec impatience mon nouveau MacMini M4 aarm64).

De plus, comme je vais fournir ce script à des utilisateurs, je ne tiens pas à les obliger à installer quoi que ce soit de plus que ce qu'ils n'ont déjà par défaut sur leurs systèmes, les versions de Linux étant déjà de plus en plus grosses (à commencer par Ubuntu qui n'apporte pas que de bonnes choses en particulier avec Wayland), et je pense qu'il n'est pas nécessaire de les surcharger encore un peu plus, surtout avec des outils dont ils n'ont pas besoin au quotidien.

Merci quand mêlme de ton code que je ne manquerai pas d'essayer plus tard (pour ma gouverne perssonnelle).

Une petite question quand même : après une lecture très rapide de tes codes, j'ai cru comprendre qu'il te faut deux programmes : a) un script lanceur et b) un exécutable (qui peut être aussi un script bash) dont on veut afficher la progression. Est-ce bien le cas ?

N'est-il alors pas possible de faire les deux tâches dans un seul et unique script (ce que justement je cherche à faire) ?

Cheers.

---

N'engage pas un débat lors d'un dîner car celui qui n'a pas faim aura le dernier mot. - R. Whately

Watael

Re : Affichage du temps passé et barre de progression en bash.

question :
comment pv sait-il où en serait un make (par exemple ) de l'accomplissement de sa tâche ?
comment détermine-t-il qu'un make en est à tel ou tel pourcentage de la fin ?

Dernière modification par Watael (Le 25/05/2026, à 01:38)

---

Connected \o/
Welcome to sHell. · eval is evil.

fnux

Re : Affichage du temps passé et barre de progression en bash.

Bonjour Watael,

time ne s'actualise pas pendant le processus; il donne le résultat à la fin.

En effet, ce qui le rend inutile pour ce que je cherche à faire.

J'ai cependant bien recherché tout ce week-end une solution à mon problème mais je fais face à deux écueils :

1) j'ai réalisé un petit script bash qui dans la premiière partie affiche un timer et voudrait être ce qui lancera la suite du script dans une boucle sans fin, mais premier écueil, je ne sais pas comment sortir "proprement de cette boucle (actuellement, j'utilise un sale Ctrl C).

En voici le code:

#!/bin/bash
#
# File     : show-time.sh
#
my_pid=$$
script_date1=$(date)
SECONDS="0"
script_start=$SECONDS
Response=""
Stop_script=""

clear
echo "Hello $USER"
echo ""
echo "Please wait until you see the message [Ok, I'm done!]"
#echo "The script sarts at: ${script_date1:11:8}"
echo "The script starts on $script_date1"
while [ $my_pid ]
  do
    script_stop=$SECONDS
    script_hour=$(( ($script_stop-$script_start) / 3600))
    script_minutes=$(( ($script_stop-$script_start) %3600 /60))
    script_seconds=$(( ($script_stop-$script_start) %3600 %60))
    
    printf  "Now, it's :          $(date) - elapsed time $script_hour : $script_minutes : $script_seconds \r"
    
    sleep 1
done
#
# How to integrate this code into the next bash script part which launch a compilation?
#

2) voici le code complet de mon script dans lequel j'aimerai afficher au minimum un timer et au mieux une barre de progression :

#!/bin/bash
#
# File     : compile-stuff.sh
#
# Note:
# -----
# To use this script, place it in the folder where you have installed the 
# source files to compile.
#
# Then, start the command: [./compil.sh file_name] (of the executable to create)
#
# Then, accordingly to the job, wait to get the executable to be done.
#
# This is why I whish to show the running elapsed time as well as a progress bar.
#
# Enjoy.
#
job_name=$1                       # name of the executable to create
if [ "$job_name" == ""  ]
  then
    echo "-------------------------------------------------------------------------------"
    echo ""
    echo "Hey $USER,"
    echo ""
    echo "Sorry, you must give the name of the stuff to compile."
    echo ""
    echo "Please retry."
    echo ""
    echo "See you later. ;)"
    echo ""
    echo "-------------------------------------------------------------------------------"
    exit
fi
echo "-------------------------------------------------------------------------------"
echo ""
echo "Hello $USER"
echo ""
echo "the stuff to compile is: $job_name"
read -p "Continue (Y/n) ?: " Response
case $Response in
  'N'|'n')
    echo "OK. Goodbye."; echo ""; exit;;
  *)
    echo "Ok, let's go but be patient, this can be long. ;)"; echo "";;
esac

script_pid=$$                      # I guess to be used later in the loop ;)
script_date1=$(date)
SECONDS="0"
script_start=$SECONDS
machine_type=`uname -m`
os_version=$(lsb_release -sc)
#clear                             # to be uncommented when the script is complete! ;)
echo "-------------------------------------------------------------------------------"
#echo "Hello $USER,"
echo ""
if [ "$machine_type" == "aarch64" ]
  then                                         # select the Makefile accpordingly to
                                               # the OS version. 
    echo "Ok $USER, your machine is an $machine_type system running $os_version."
    cp Makefile-optimised-aarch64 Makefile
  elif [ "$machine_type" == "x86_64" ]
    then
      echo "Ok $USER, your machine is an $machine_type system running $os_version."
      cp Makefile-standard-x86_64 Makefile
  else 
    echo ""
    echo "Sorry $USER, but I don't know your machine and OS types and can't continue."
    echo "Goodbye."
    echo ""
    echo "-------------------------------------------------------------------------------"
    echo ""
    exit
fi
echo ""
echo "The $job_name compilation starts on $script_date1, please wait..."
echo ""
date #################################################### <= this is where I whish to display a timer and  a progress bar.
make clean >compile-$job_name.$machine_type.log 2>&1
echo "" >>compile-$job_name.$machine_type.log 2>&1
make >>compile-$job_name.$machine_type.log 2>&1
echo ""
script_date2=$(date)
echo "The $job_name compilation ends on $script_date2."
if [ -f "$job_name" ] && [ "$machine_type" == "aarch64" ]
  then                                         # save the executable with the name of
                                               # the OS version prior to [make clean]. 
    if [ "$os_version" == "bookworm" ]
      then
        cp $job_name $job_name-aarm-Pi64-bookworm
    elif [ "$os_version" == "trixie" ]
      then
        cp $job_name $job_name-aarm-Pi64-trixie
    elif [ "$os_version" == "resolute" ]
      then
        cp $job_name $job_name-aarm-Pi64-resolute
    fi
    make clean >>compile-$job_name.$machine_type.log 2>&1    # this will also delete the executable.
    echo "The $job_name compilation is successful."
    if [ "$os_version" == "bookworm" ]
      then                                     # copy back the saved executable to its 
                                               # usual name.
        cp $job_name-aarm-Pi64-bookworm $job_name
        echo "You've got both [$job_name] and a copie named [$job_name-aarm-Pi64-bookworm]"
      elif [ "$os_version" == "trixie" ]
        then
          cp $job_name-aarm-Pi64-trixie $job_name
          echo "You've got both [$job_name] and a copie named [$job_name-aarm-Pi64-trixie]"
      elif [ "$os_version" == "resolute" ]
        then
          cp $job_name-aarm-Pi64-resolute $job_name
          echo "You've got both [$job_name] and a copie named [$job_name-aarm-Pi64-resolute]"
    fi
    echo "Enjoy using [$job_name] and its stress script. "
    echo ""
    echo "All the best."
  elif [ "$job_name" ] && [ "$machine_type" == "x86_64" ]
    then                                       # save the executable with the name of
                                               # the OS version prior to [make clean]. 
      cp $job_name $job_name-amd-x86_64
      make clean >>compile-$job_name.log 2>&1
      echo ""
      echo "The $job_name compilation is successful."
      cp $job_name-amd-x86_64 $job_name        # copy back the saved executable to its 
                                               # usual name.
      echo "You've got both [$job_name] and a copie named [$job_name-amd-x86_64]"
      echo ""
      echo "Enjoy using [$job_name] and its stress script."
      echo ""
      echo "All the best."
  else
    echo "-------------------------------------------------------------------------------"
    echo ""
    echo "Sorry $USER,"
    echo ""
    echo "Unfortunately, the $job_name compilation failed."
    echo ""
    echo "Please check the error in the compile-$job_name.$machine_type.log file, correct it and try again."
    echo ""
    echo "See you soon again."
    echo ""
    echo "All the best." 
    echo ""
    echo "-------------------------------------------------------------------------------"
    echo ""
    exit
fi
script_date3=$(date)
script_stop=$SECONDS
script_hour=$(( ($script_stop-$script_start) / 3600))
script_minutes=$(( ($script_stop-$script_start) %3600/60))
script_seconds=$(( ($script_stop-$script_start) %3600 %60))
echo "-------------------------------------------------------------------------------"
echo "Compilation starts      : $script_date1"
echo "Compilation ends        : $script_date3"
echo "Compilation elapŝed time: "$script_hour"h : "$script_minutes"m : "$script_seconds"s"
echo ""
echo "It's done! Goodbye."
echo "-------------------------------------------------------------------------------"
exit

Voici aussi le retour console avec les prompts de l'exécution de ce script sur mon Raspberry Pi 500+ :

fnux@rpi-26-04-lts:~/work-u2604$ time ./compile-stuff.sh my-stuff
-------------------------------------------------------------------------------

Hello fnux

the stuff to compile is: my-stuff
Continue (Y/n) ?: y
Ok, let's go but be patient, this can be long. ;)

-------------------------------------------------------------------------------

Ok fnux, your machine is an aarch64 system running resolute.

The my-stuff compilation starts on Sun May 24 17:24:36 EDT 2026, please wait...

Sun May 24 17:24:36 EDT 2026 ################# <= this is where I whish to display a timer and  a progress bar.

The my-stuff compilation ends on Sun May 24 17:31:36 EDT 2026.
The my-stuff compilation is successful.
You've got both [my-stuff] and a copie named [my-stuff-aarm-Pi64-resolute]
Enjoy using [my-stuff] and its stress script. 

All the best.
-------------------------------------------------------------------------------
Compilation starts      : Sun May 24 17:24:36 EDT 2026
Compilation ends        : Sun May 24 17:31:36 EDT 2026
Compilation elapŝed time: 0h : 7m : 0s

It's done! Goodbye.
-------------------------------------------------------------------------------

real	7m1.070s
user	5m54.104s
sys	1m3.803s
fnux@rpi-26-04-lts:~/work-u2604$ 

Et le retour console avec les prompts du même script exécuté sur pmon Asus Rog 750 i7 x86_64, ce qui montre bien que pour exactement le même job, les temps d'exécution sont différents en raison de la différence d'environnement  (hardware et OS)

fnux@G750JM-Ubuntu:~/work-ubuntu$ time ./compile-my-stuff.sh my-stuff
-------------------------------------------------------------------------------

Hello fnux

the stuff to compile is: my-stuff
Continue (Y/n) ?: y
Ok, let's go but be patient, this can be long. ;)

-------------------------------------------------------------------------------

Ok fnux, your machine is an x86_64 system running noble.

The my-stuff compilation starts on Sun May 24 11:25:41 PM CEST 2026, please wait...

Sun May 24 11:25:41 PM CEST 2026 ################# <= this is where I whish to display a timer and  a progress bar.

The my-stuff compilation ends on Sun May 24 11:30:28 PM CEST 2026.

The my-stuff compilation is successful.
You've got both [my-stuff] and a copie named [my-stuff-amd-x86_64]

Enjoy using [my-stuff] and its stress script.

All the best.
-------------------------------------------------------------------------------
Compilation starts      : Sun May 24 11:25:41 PM CEST 2026
Compilation ends        : Sun May 24 11:30:28 PM CEST 2026
Compilation elapŝed time: 0h : 4m : 47s

It's done! Goodbye.
-------------------------------------------------------------------------------

real	4m49.582s
user	4m7.942s
sys	0m38.187s
fnux@G750JM-Ubuntu:~/work-ubuntu$ 

Aurais tu une idée de comment y parvenir ?

Merci d'avance de toute suggestion.

Cheers.

PS: J'ai intégré un log à consulter en cas d'erreur de compilation.

Dernière modification par fnux (Le 29/05/2026, à 18:13)

---

N'engage pas un débat lors d'un dîner car celui qui n'a pas faim aura le dernier mot. - R. Whately

krodelabestiole

Re : Affichage du temps passé et barre de progression en bash.

comment pv sait-il où en serait un make (par exemple ) de l'accomplissement de sa tâche ?
comment détermine-t-il qu'un make en est à tel ou tel pourcentage de la fin ?

pv ou n'importe quel outil !

même si tu pouvais compter où tu en es ligne par ligne, ça n'aurait aucun sens.

et il faudrait au moins que l'outil permettant l'estimation de la progression soit inclus dans le compilateur. À ma connaissance ce n'est jamais le cas, nulle part - ce n'est sans doute pas faisable (ou peut-être très difficilement, au moment de la conception du compilateur), mais je peux me tromper.

il existe apparemment des estimateurs de temps de compilation, dépendant du processeur : https://gentoo.linuxhowtos.org/compiletimeestimator/
donc mouais, ça semble faisable de produire une estimation de la durée d'une compilation, en pompant les informations matérielles, à comparer à la durée écoulée... pas sûr que le jeu en vaille la chandelle.

---

nouveau forum ubuntu-fr on en parle là : refonte du site / nouveau design
profil - sujets récurrents - sources du site

Watael

Re : Affichage du temps passé et barre de progression en bash.

je peux donc comprendre que mon "afaik" n'était pas erroné, c'est ça ?

@fnux:
ton code deviendrais

make clean &>"/chemin/absolu/compile-$job_name.$machine_type.log" & #mise en arrière plan
while read -r time
do
    echo "$time" #il vaudrait bien sûr mieux utiliser `printf'  avec des codes d'échappement ANSI pour avoir un affichage sur une seule ligne mise à jour
done < <(ps h -p $! -o time)
#puis pareil pour `make'...

a priori.
pas testé !

edit : le premier esperluette effectue la redirection de stdout et de stderr

Dernière modification par Watael (Le 25/05/2026, à 04:28)

---

Connected \o/
Welcome to sHell. · eval is evil.

fnux

Re : Affichage du temps passé et barre de progression en bash.

Bonsoir Watael et krodelabestiole,

comment pv sait-il où en serait un make (par exemple ) de l'accomplissement de sa tâche ?
comment détermine-t-il qu'un make en est à tel ou tel pourcentage de la fin ?

pv ou n'importe quel outil !

même si tu pouvais compter où tu en es ligne par ligne, ça n'aurait aucun sens.

et il faudrait au moins que l'outil permettant l'estimation de la progression soit inclus dans le compilateur. À ma connaissance ce n'est jamais le cas, nulle part - ce n'est sans doute pas faisable (ou peut-être très difficilement, au moment de la conception du compilateur), mais je peux me tromper.

il existe apparemment des estimateurs de temps de compilation, dépendant du processeur : https://gentoo.linuxhowtos.org/compiletimeestimator/
donc mouais, ça semble faisable de produire une estimation de la durée d'une compilation, en pompant les informations matérielles, à comparer à la durée écoulée... pas sûr que le jeu en vaille la chandelle.

D'après mes longues recherches, ni pv ni aucun autre outil ne sait mesurer la durée très variable de la compilation de code.

Et l'estimaitor de gentoo est pour le moins assez "farfelu" car ces temps ne dépendent pas uniquement de la puissance des CPU mais de l'environnement complet (CPU, RAM et vitesse d'i/o disque ainsi que du type d'OS (différents Linux, différents macOS, voir même WinWin) de sa version sans oublier son paramétrage, comme le démontre les deux copies de retour console que j'ai fournies (Raspberry PI 500+ ARM Kortex K76 4 cores single thread @ 2,4 GHz et Asus Rog 750 Intel i7 4 cores dual thread @ 3,5 GHz).

De plus, sa liste de CPU est complètement obsolète

J'ai un pote qui a une machine de guerre CPU Intel 32 cores, 192 GB de RAM, SSD ultra rapides chez qui sous Ubuntu 24.04 LTS à jour, mon script s'exécute en à peine une minute.

Autre exemple, sur un de mes 2 iMac 27 i7 4+4 cores, RAM 32 GB, SSD Crucial de 2 To, le make de Mono prend plus de 25 minutes !

C'est pourquoi, pour ce besoin particulier, je souhaite à minima afficher un timer car ne connaissant pas la durée du job, il me semble assez impossible d'afficher une quelconque barre de progression, sauf à entrer en paramètre une durée basée sur des mesures déjà réalisées.

Néanmoins, si l'on met de côté que le job est une compilation, mon problème reste le même pour un script dont je connais exactement la durée d'exécution comme par exemple celui d'un stress de très haute intensité qui dure près 2 fois 4 heures avec les cores qui tournent jusqu'à 100%.

Donc, dans ce cas plus "générique" ou la durée est connue, si vous avez une idée de comment afficher ce timer et cette barre de progression, en se basant sur une intégration dans mon script et donc en remplaçant les "make" par n'importe quelle autre commande, je suis vraiment preneur car pour l'instant, je n'entrevois pas la solution.

Merci d'avance de vos conseils avisés.

Cheers.

---

N'engage pas un débat lors d'un dîner car celui qui n'a pas faim aura le dernier mot. - R. Whately

Hizoka

Re : Affichage du temps passé et barre de progression en bash.

Salut,
pour la barre en elle même j'avais créé un truc qui peut peut être t’intéresser : https://github.com/Hizoka76/HizoProgress

---

KDE Neon 64bits
Tous mes softs (MKVExtractorQt, HizoSelect, HizoProgress, Qtesseract, Keneric, Services menus...) sont sur github