Mengatur waktu eksekusi perintah di PowerShell

Apakah ada cara sederhana untuk menentukan waktu pelaksanaan perintah di PowerShell, seperti perintah 'waktu' di Linux?
Saya datang dengan ini:

$s=Get-Date; .\do_something.ps1 ; $e=Get-Date; ($e - $s).TotalSeconds

Tapi saya ingin sesuatu yang lebih sederhana

time .\do_something.ps1

Ya.

Measure-Command { .\do_something.ps1 }

Perhatikan bahwa satu kelemahan minor Measure-Commandadalah Anda tidak melihat stdoutoutput.

[Perbarui, terima kasih kepada @JasonMArcher] Anda dapat memperbaikinya dengan menyalurkan output perintah ke beberapa commandlet yang menulis ke host, mis. Out-DefaultSehingga menjadi:

Measure-Command { .\do_something.ps1 | Out-Default }

Cara lain untuk melihat hasilnya adalah menggunakan Stopwatchkelas .NET seperti ini:

$sw = [Diagnostics.Stopwatch]::StartNew()
.\do_something.ps1
$sw.Stop()
$sw.Elapsed

Anda juga bisa mendapatkan perintah terakhir dari histori dan mengurangi EndExecutionTimedari itu StartExecutionTime.

.\do_something.ps1  
$command = Get-History -Count 1  
$command.EndExecutionTime - $command.StartExecutionTime

Menggunakan Measure-Command

Contoh

Measure-Command { <your command here> | Out-Host }

Pipa untuk Out-Hostmemungkinkan Anda melihat output dari perintah, yang jika tidak dikonsumsi oleh Measure-Command.

Sederhana

function time($block) {
    $sw = [Diagnostics.Stopwatch]::StartNew()
    &$block
    $sw.Stop()
    $sw.Elapsed
}

kemudian bisa digunakan sebagai

time { .\some_command }

Anda mungkin ingin mengubah output

Inilah fungsi yang saya tulis yang bekerja mirip dengan timeperintah Unix :

function time {
    Param(
        [Parameter(Mandatory=$true)]
        [string]$command,
        [switch]$quiet = $false
    )
    $start = Get-Date
    try {
        if ( -not $quiet ) {
            iex $command | Write-Host
        } else {
            iex $command > $null
        }
    } finally {
        $(Get-Date) - $start
    }
}

Sumber: https://gist.github.com/bender-the-greatest/741f696d965ed9728dc6287bdd336874

Menggunakan Stopwatch dan memformat waktu yang telah berlalu:

Function FormatElapsedTime($ts) 
{
    $elapsedTime = ""

    if ( $ts.Minutes -gt 0 )
    {
        $elapsedTime = [string]::Format( "{0:00} min. {1:00}.{2:00} sec.", $ts.Minutes, $ts.Seconds, $ts.Milliseconds / 10 );
    }
    else
    {
        $elapsedTime = [string]::Format( "{0:00}.{1:00} sec.", $ts.Seconds, $ts.Milliseconds / 10 );
    }

    if ($ts.Hours -eq 0 -and $ts.Minutes -eq 0 -and $ts.Seconds -eq 0)
    {
        $elapsedTime = [string]::Format("{0:00} ms.", $ts.Milliseconds);
    }

    if ($ts.Milliseconds -eq 0)
    {
        $elapsedTime = [string]::Format("{0} ms", $ts.TotalMilliseconds);
    }

    return $elapsedTime
}

Function StepTimeBlock($step, $block) 
{
    Write-Host "`r`n*****"
    Write-Host $step
    Write-Host "`r`n*****"

    $sw = [Diagnostics.Stopwatch]::StartNew()
    &$block
    $sw.Stop()
    $time = $sw.Elapsed

    $formatTime = FormatElapsedTime $time
    Write-Host "`r`n`t=====> $step took $formatTime"
}

Sampel Penggunaan

StepTimeBlock ("Publish {0} Reports" -f $Script:ArrayReportsList.Count)  { 
    $Script:ArrayReportsList | % { Publish-Report $WebServiceSSRSRDL $_ $CarpetaReports $CarpetaDataSources $Script:datasourceReport };
}

StepTimeBlock ("My Process")  {  .\do_something.ps1 }

Hanya satu kata di gambar (salah) kesimpulan dari salah satu perintah pengukuran kinerja yang disebut dalam jawaban. Ada sejumlah jebakan yang harus dipertimbangkan selain dari melihat ke waktu pemanggilan fungsi (perintah) yang kosong.

Perangkat lunak Sjoemels

_{'Sjoemelsoftware' memilih kata Belanda tahun 2015
Sjoemelen berarti curang, dan kata sjoemelsoftware muncul karena skandal emisi Volkswagen. Definisi resmi adalah "perangkat lunak yang digunakan untuk memengaruhi hasil tes".}

Secara pribadi, saya berpikir bahwa " Sjoemelsoftware " tidak selalu sengaja dibuat untuk menipu hasil tes tetapi mungkin berasal dari mengakomodasi situasi praktis yang mirip dengan kasus uji seperti yang ditunjukkan di bawah ini.

Sebagai contoh, menggunakan perintah pengukuran kinerja yang terdaftar, Integrated Query Language (LINQ) ⁽¹⁾ , sering memenuhi syarat seperti yang cara berpuasa untuk mendapatkan sesuatu dilakukan dan itu sering, tetapi tentu tidak selalu! Siapa pun yang mengukur peningkatan kecepatan faktor 40 atau lebih dibandingkan dengan perintah PowerShell asli, mungkin salah mengukur atau menarik kesimpulan yang salah.

Intinya adalah bahwa beberapa kelas .Net (seperti LINQ) menggunakan evaluasi malas (juga disebut sebagai eksekusi ditangguhkan ⁽²⁾ ). Berarti ketika menetapkan ekspresi ke variabel, tampaknya segera dilakukan tetapi sebenarnya belum memproses apa-apa!

Mari kita anggap bahwa Anda dot-source. .\Dosomething.ps1 perintah Anda yang memiliki PowerShell atau ekspresi Linq yang lebih canggih (untuk kemudahan penjelasan, saya telah langsung memasukkan ekspresi langsung ke dalam Measure-Command):

$Data = @(1..100000).ForEach{[PSCustomObject]@{Index=$_;Property=(Get-Random)}}

(Measure-Command {
    $PowerShell = $Data.Where{$_.Index -eq 12345}
}).totalmilliseconds
864.5237

(Measure-Command {
    $Linq = [Linq.Enumerable]::Where($Data, [Func[object,bool]] { param($Item); Return $Item.Index -eq 12345})
}).totalmilliseconds
24.5949

Hasilnya tampak jelas, perintah Linq selanjutnya adalah sekitar 40 kali lebih cepat dari perintah PowerShell pertama . Sayangnya, tidak sesederhana itu ...

Mari kita tampilkan hasilnya:

PS C:\> $PowerShell

Index  Property
-----  --------
12345 104123841

PS C:\> $Linq

Index  Property
-----  --------
12345 104123841

Seperti yang diharapkan, hasilnya sama tetapi jika Anda telah memperhatikan dengan seksama, Anda akan memperhatikan bahwa butuh waktu lebih lama untuk menampilkan $Linqhasilnya daripada $PowerShellhasilnya.
Mari kita secara khusus mengukur bahwa dengan hanya mengambil properti dari objek mengakibatkan:

PS C:\> (Measure-Command {$PowerShell.Property}).totalmilliseconds
14.8798
PS C:\> (Measure-Command {$Linq.Property}).totalmilliseconds
1360.9435

Butuh sekitar 90 faktor lebih lama untuk mengambil properti dari $Linqobjek kemudian $PowerShellobjek dan itu hanya satu objek!

Juga perhatikan perangkap lain bahwa jika Anda melakukannya lagi, langkah-langkah tertentu mungkin terlihat jauh lebih cepat daripada sebelumnya, ini karena beberapa ekspresi telah di-cache.

Intinya, jika Anda ingin membandingkan kinerja antara dua fungsi, Anda perlu mengimplementasikannya dalam kasing bekas Anda, mulailah dengan sesi PowerShell yang baru dan simpulkan kesimpulan Anda pada kinerja aktual dari solusi lengkap.

_{(1) Untuk latar belakang dan contoh lebih lanjut tentang PowerShell dan LINQ, saya sarankan situs ini: PowerShell Kinerja Tinggi dengan LINQ
(2) Saya pikir ada perbedaan kecil antara dua konsep karena dengan evaluasi malas hasilnya dihitung ketika dibutuhkan sebagaimana yang seharusnya. eksekusi yang ditunda adalah hasilnya dihitung ketika sistem idle}