තිර රචනයක සම්පූර්ණ කාලය ප්‍රදර්ශනය කිරීමට මම කැමතියි.

මම දැනට කරන්නේ -

#!/bin/bash
date  ## echo the date at start
# the script contents
date  ## echo the date at end

මෙය පෙන්වන්නේ තිර රචනය ආරම්භ වන හා අවසන් වන කාලයයි. ප්‍රොසෙසර් වේලාව / io වේලාව වැනි සියුම් නිමැවුම් ප්‍රදර්ශනයක් පෙන්විය හැකිද?

timeඔබ ස්ක්‍රිප්ට් එක අමතන විට භාවිතා කරන්න:

time yourscript.sh

නම් timeවිකල්පයක් නොවේ,

start=`date +%s`
stuff
end=`date +%s`

runtime=$((end-start))

timesඔබගේ ස්ක්‍රිප්ට් එකෙන් පිටවීම ගැන තර්කයකින් තොරව අමතන්න .

සමඟ kshහෝ zsh, ඔබට timeඒ වෙනුවට භාවිතා කළ හැකිය . සමඟ zsh, පරිශීලකයාට සහ පද්ධතියේ CPU වේලාවට timeඅමතරව බිත්ති ඔරලෝසු කාලයද ලබා දෙනු ඇත .

ඔබගේ ස්ක්‍රිප්ටයේ පිටවීමේ තත්වය ආරක්ෂා කර ගැනීම සඳහා, ඔබට එය කළ හැකිය:

ret=$?; times; exit "$ret"

නැතහොත් ඔබට උගුලක් එකතු කළ හැකිය EXIT:

trap times EXIT

ඒ ආකාරයෙන්, කවචය පිටවන සෑම විටම වේලාවන් කැඳවනු ලබන අතර පිටවීමේ තත්වය ආරක්ෂා වේ.

$ bash -c 'trap times EXIT; : {1..1000000}'
0m0.932s 0m0.028s
0m0.000s 0m0.000s
$ zsh -c 'trap time EXIT; : {1..1000000}'
shell  0.67s user 0.01s system 100% cpu 0.677 total
children  0.00s user 0.00s system 0% cpu 0.677 total

ද සියලු බවයි සටහන් bash, kshහා zshඇති $SECONDSසෑම දෙවන ස්වයංක්රීයව නිලධාරිෙයකු රැඳි විශේෂ විචල්ය. දෙකෙහිම zshසහ ksh93, එම විචල්‍යය typeset -F SECONDSවඩාත් නිරවද්‍යතාව ලබා ගැනීම සඳහා පාවෙන ලක්ෂ්‍යයක් (සමඟ ) කළ හැකිය. මෙය බිත්ති ඔරලෝසු කාලය මිස CPU වේලාව නොවේ.

මම බෑන්ඩ්වැගන් වෙත ටිකක් ප්‍රමාදයි, නමුත් සෙවීම තුළින් අනෙක් අය මෙම නූලට පැකිලීමට සිදුවුවහොත් මගේ විසඳුම (උප තත්පර නිරවද්‍යතාව සඳහා) පළ කිරීමට අවශ්‍ය විය. ප්‍රතිදානය දින, පැය, මිනිත්තු සහ අවසාන තත්පර ආකාරයෙන් වේ:

res1=$(date +%s.%N)

# do stuff in here

res2=$(date +%s.%N)
dt=$(echo "$res2 - $res1" | bc)
dd=$(echo "$dt/86400" | bc)
dt2=$(echo "$dt-86400*$dd" | bc)
dh=$(echo "$dt2/3600" | bc)
dt3=$(echo "$dt2-3600*$dh" | bc)
dm=$(echo "$dt3/60" | bc)
ds=$(echo "$dt3-60*$dm" | bc)

LC_NUMERIC=C printf "Total runtime: %d:%02d:%02d:%02.4f\n" $dd $dh $dm $ds

පිටත සිටින කෙනෙකුට මෙය ප්‍රයෝජනවත් වේ යැයි සිතමි!

මගේ ක්‍රමය bash:

# Reset BASH time counter
SECONDS=0
    # 
    # do stuff
    # 
ELAPSED="Elapsed: $(($SECONDS / 3600))hrs $((($SECONDS / 60) % 60))min $(($SECONDS % 60))sec"

මෙම ප්‍රශ්නය තරමක් පැරණි නමුත් එය කිරීමට මගේ ප්‍රියතම ක්‍රමය සොයා ගැනීමට උත්සාහ කිරීමේදී මෙම ත්‍රෙඩ් එක ඉහළට පැමිණියේය ... කිසිවෙකු එය සඳහන් නොකිරීම ගැන මම පුදුම වෙමි:

perf stat -r 10 -B sleep 1

'පර්ෆ්' යනු කර්නල් තුළ 'මෙවලම් / පර්ෆ්' යටතේ ඇතුළත් කර ඇති කාර්ය සාධන විශ්ලේෂණ මෙවලමක් වන අතර එය බොහෝ විට වෙනම පැකේජයක් ලෙස ස්ථාපනය කිරීමට ලබා ගත හැකිය (සෙන්ටෝස් හි 'පර්ෆ්' සහ ඩෙබියන් / උබුන්ටු මත 'ලිනක්ස්-මෙවලම්'). ලිනක්ස් කර්නල් පර්ෆ් විකියෙහි ඒ පිළිබඳ තවත් බොහෝ තොරතුරු ඇත.

'පර්ෆ් ස්ටාට්' ධාවනය කිරීමෙන් අවසානයේ ක්‍රියාත්මක වන සාමාන්‍ය කාලය ඇතුළුව විස්තර ටිකක් ලැබේ:

1.002248382 seconds time elapsed                   ( +-  0.01% )

#!/bin/bash
start=$(date +%s.%N)

# HERE BE CODE

end=$(date +%s.%N)    
runtime=$(python -c "print(${end} - ${start})")

echo "Runtime was $runtime"

ඔව්, මෙය පයිතන් ලෙස හැඳින්වේ, නමුත් ඔබට එය සමඟ ජීවත් විය හැකි නම් මෙය ඉතා හොඳ, දැඩි විසඳුමකි.

පුද්ගලිකව, මම කැමතියි මගේ සියලුම ස්ක්‍රිප්ට් කේතය සමහර “ප්‍රධාන” ශ්‍රිතයක් තුළට එතීමට:

main () {
 echo running ...
}

# stuff ...

# calling the function at the very end of the script
time main

timeමෙම අවස්ථාවෙහිදී විධානය භාවිතා කිරීම කොතරම් පහසුදැයි බලන්න . නිසැකවම ඔබ ස්ක්‍රිප්ට් විග්‍රහ කිරීමේ වේලාව ඇතුළුව නිශ්චිත වේලාව මනින්නේ නැත, නමුත් බොහෝ අවස්ථාවන්හිදී එය ප්‍රමාණවත් තරම් නිවැරදි බව මට පෙනේ.

ඔවුන්ගේ කාලය මැනීම සඳහා විධාන වලට පෙර එකතු කළ හැකි කුඩා ෂෙල් ශ්‍රිතයක්:

tm() {
  local start=$(date +%s)
  $@
  local exit_code=$?
  echo >&2 "took ~$(($(date +%s)-${start})) seconds. exited with ${exit_code}"
  return $exit_code
}

ඉන්පසු එය ඔබගේ ස්ක්‍රිප්ටයේ හෝ ඔබේ විධාන රේඛාවේ භාවිතා කරන්න:

tm the_original_command with all its parameters

මෙන්න ඇලෙක්ස්ගේ පිළිතුරේ විචලනයකි. මම සැලකිලිමත් වන්නේ මිනිත්තු සහ තත්පර ගැන පමණයි, නමුත් මට අවශ්‍ය වූයේ එය වෙනස් ආකාරයකින් සංයුති කිරීමයි. ඉතින් මම මේක කළා:

start=$(date +%s)
end=$(date +%s)
runtime=$(python -c "print '%u:%02u' % ((${end} - ${start})/60, (${end} - ${start})%60)")

#!/bin/csh
#PBS -q glean
#PBS -l nodes=1:ppn=1
#PBS -l walltime=10:00:00
#PBS -o a.log
#PBS -e a.err
#PBS -V
#PBS -M shihcheng.guo@gmail.com
#PBS -m abe
#PBS -A k4zhang-group
START=$(date +%s)
for i in {1..1000000}
do
echo 1
done
END=$(date +%s)
DIFF=$(echo "$END - $START" | bc)
echo "It takes DIFF=$DIFF seconds to complete this task..."

බාෂ් පමණක් භාවිතා කිරීමෙන් ෂෙල් ස්ක්‍රිප්ටයේ කොටසක් සඳහා කාල සීමාව මැනීමට සහ ගණනය කිරීමට හැකිය (හෝ සමස්ත පිටපත සඳහා ගත වූ කාලය):

start=$SECONDS

... # do time consuming stuff

end=$SECONDS

ඔබට දැන් වෙනස මුද්‍රණය කළ හැකිය:

echo "duration: $((end-start)) seconds."

ඔබට අවශ්‍ය වන්නේ වර්ධක කාල සීමාව පමණි:

echo "duration: $((SECONDS-start)) seconds elapsed.."

ඔබට කාල සීමාව විචල්යයකින් ගබඩා කළ හැකිය:

let diff=end-start

SECONDSදෙවන මට්ටමේ කැටිති වලට පමණක් සීමා වූ කාල ශ්‍රිතය බාහිර විධානයන් භාවිතා නොකරයි:

time_it() {
  local start=$SECONDS ts ec
  printf -v ts '%(%Y-%m-%d_%H:%M:%S)T' -1
  printf '%s\n' "$ts Starting $*"
  "$@"; ec=$?
  printf -v ts '%(%Y-%m-%d_%H:%M:%S)T' -1
  printf '%s\n' "$ts Finished $*; elapsed = $((SECONDS-start)) seconds"
  # make sure to return the exit code of the command so that the caller can use it
  return "$ec"
}

උදාහරණයක් වශයෙන්:

time_it sleep 5

ලබා දෙයි

2019-03-30_17:24:37 Starting sleep 5 2019-03-30_17:24:42 Finished
sleep 5; elapsed = 5 seconds

#!/bin/bash
begin=$(date +"%s")

Script

termin=$(date +"%s")
difftimelps=$(($termin-$begin))
echo "$(($difftimelps / 60)) minutes and $(($difftimelps % 60)) seconds elapsed for Script Execution."

Bash සඳහා, අභ්‍යන්තර $SECONDSවිචල්‍යය භාවිතා කරන්න . මෙන්න නිරූපණයක්:

(තත්පර 1 = මිනිත්තු ගණනක්) සිට මේ අවස්ථාවේ දී dt_minවටකුරු වන බව සලකන්න . මෙම ඔබ ලකුණු හා වේලාව ඔබේ තිර රචනය කතා කියලා එහිදී පහත කොටසක්, නමුත් මම මේ Demo වෙනුවෙන් වෙනුවට දෙවන 1 නිදාගෙන ඉන්නේ:0.01666666666...0.017printfsleep 1;

start=$SECONDS; sleep 1; end=$SECONDS; dt_sec=$(( end - start )); dt_min=$(printf %.3f $(echo "$dt_sec/60" | bc -l)); echo "dt_sec = $dt_sec; dt_min = $dt_min"
dt_sec = 1; dt_min = 0.017

ආශ්‍රිත:

• වැඩි විස්තර bcසහ printfමගේ පිළිතුර මෙතැනින් කියවන්න: /programming/12722095/how-do-i-use-floating-point-division-in-bash/58479867#58479867

බාෂ් ටයිම් බිල්ඩින් භාවිතා කරන්නද?

time: time [-p] PIPELINE
    Execute PIPELINE and print a summary of the real time, user CPU time,
    and system CPU time spent executing PIPELINE when it terminates.
    The return status is the return status of PIPELINE.  The `-p' option
    prints the timing summary in a slightly different format.  This uses
    the value of the TIMEFORMAT variable as the output format.

උදාහරණයක්:

TIMEFORMAT="The command took %Rs"
time {
    sleep 0.1
}

ප්‍රතිදානය:

The command took 0.108s