Polecenie „Top” systemu Linux dla programu Windows Powershell?

Szukam polecenia cmdlet programu PowerShell, które może zapewnić podobną funkcjonalność jak aplikacja Linux Top. Coś, co odświeża się w danym interwale i wyświetla listę procesów z procentowym wykorzystaniem procesora.

Widziałem skrypty, które wyświetlają procent wykorzystania procesora w pętli, ale coś takiego jak top byłoby o wiele bardziej przydatne, ponieważ mamy skonfigurowany dostęp do SSH / Powershell do zarządzania (nadal wolę putty shell!)

While(1) {ps | sort -des cpu | select -f 15 | ft -a; sleep 1; cls}

Jest to prosta wkładka, która zachowa również etykiety na górze.

Działa to, ponieważ formatowanie tabeli bez żadnych parametrów po prostu rysuje tabelę domyślną. autosize służy do automatycznego dostosowania szerokości kolumny, aby wszystkie dane mogły zmieścić się na ekranie.

Oto zestawienie zastosowanych skróconych poleceń

• select -f to skrót od -first
• ft to skrót do Format-Table
• -a to skrót od -autosize
• uśpienie domyślnie używa sekund

Nic nie wiem o tym w postaci pojedynczego polecenia cmdlet, ale jak mówisz, skrypty można łatwo napisać, aby emulować górę.

while (1) { ps | sort -desc cpu | select -first 30; sleep -seconds 2; cls }

Podobne rozwiązanie jak inne, ale przy użyciu Get-Counter zamiast Get-Process.

While(1) { $p = get-counter '\Process(*)\% Processor Time'; cls; $p.CounterSamples | sort -des CookedValue | select -f 15 | ft -a}

Przykładowe dane wyjściowe:

Path                                                      InstanceName              CookedValue
----                                                      ------------              -----------
\\server_name\process(_total)\% processor time                 _total               4806.03969127454
\\server_name\process(idle)\% processor time                   idle                 1103.7573538257
\\server_name\process(program#2)\% processor time              program              749.692930701698
\\server_name\process(program#5)\% processor time              program              563.424255927765
\\server_name\process(program#1)\% processor time              program              535.714866291973
\\server_name\process(program#6)\% processor time              program              455.665518455242
\\server_name\process(program#3)\% processor time              program              426.416718284128
\\server_name\process(program)\% processor time                program              395.628507577693
\\server_name\process(program#4)\% processor time              program              335.591496700144
\\server_name\process(microsoftedgecp#2)\% processor time      microsoftedgecp      129.310484967028
\\server_name\process(system)\% processor time                 system               80.0493478367316
\\server_name\process(chrome#8)\% processor time               chrome               1.53941053532176

Znalazłem tutaj większość innych rozwiązań wykorzystujących raport get-process o całkowitym czasie pracy procesora od początku procesu. Nie przydało mi się to na moim serwerze, który działa 24 godziny na dobę, 7 dni w tygodniu, gdzie najwyższy wynik zawsze był sprawiedliwy svchosti wynosił systemmiliony sekund. Prawda toplub odpowiednik Menedżera zadań dałby migawkę ostatnio zarejestrowanego użycia procesora w określonym czasie, a Get-Counter to zapewnia. Ponieważ ten post Superuser jest nadal najlepszym wynikiem Google dla „powerhell top”, pomyślałem, że ta alternatywa jest warta wniesienia wkładu.

Moje polecenie jest oparte na przykładzie 13 z dokumentów Get-Counter: https://docs.microsoft.com/en-us/powershell/module/Microsoft.PowerShell.Diagnostics/Get-Counter .
Oto podział jednej linijki, abyś mógł ją łatwiej dostosować do swoich potrzeb:

• While(1) { po prostu zapętla to
• get-counter '\Process(*)\% Processor Time'wybiera dane% procesora. Wydaje się, że polecenie to wymaga dużo czasu, więc nie trzebasleep
• cls jasne dla nowego stołu
• sort -des CookedValue CookedValue to dziedzina, w której jesteśmy intestowani. Sortuj według najwyższych
• select -f 15 pokaż pierwsze 15
• ft -a wyświetlać w sformatowanej tabeli

Zapewnia ładne nagłówki u góry każdej aktualizacji bez konieczności czyszczenia całej konsoli.

$saveY = [console]::CursorTop
$saveX = [console]::CursorLeft      

while ($true) {
    Get-Process | Sort -Descending CPU | Select -First 30;
    Sleep -Seconds 2;
    [console]::setcursorposition($saveX,$saveY+3)
}

Nie znam polecenia cmdlet programu PowerShell, które zapewnia tę funkcjonalność. Istnieje bezpłatne zewnętrzne polecenie, które robi to, co chcesz. Spójrz na pslistę Marka Russinovicha z pakietu Sysinternals. Pslist zapewnia listę wykonujących się procesów w konfigurowalnym widoku. „pslist -s” zapewnia rodzaj ciągłej aktualizacji, której potrzebujesz, z domyślną częstotliwością odświeżania raz na sekundę.

Wolę używać Mark GUI Process Explorer, ale pslist jest przydatny do sesji konsolowych.

Strona główna Sysinternals znajduje się tutaj: http://technet.microsoft.com/en-us/sysinternals

Dennis

while (1) {ps | sort -desc cpu | select -first 30; 
sleep -seconds 2; cls; 
write-host "Handles  NPM(K)    PM(K)      WS(K) VM(M)   CPU(s)     Id ProcessName"; 
write-host "-------  ------    -----      ----- -----   ------     -- -----------"}

To tylko trochę przyjemniejszy sposób, ponieważ za każdym razem możesz zobaczyć nagłówki na górze

Chciałbym również zaznaczyć, że jeśli chcesz środowisko Linux-a dla systemu Windows, możesz użyć Cygwin. Wprowadza środowisko Linux do systemu Windows. Możesz użyć prawie każdego polecenia. Nie jestem jednak pewien, jak przydatne jest to dla Ciebie.

http://www.cygwin.com/

Może to również załatwić sprawę:

function htopish {
  Param (
    [Parameter(Position=1)] [Alias("l")]
    [int]$TotalList=24,
    [Parameter(Position=2)] [Alias("r")]
    [int]$Invertal=1
  )
  Begin {}
  Process {
    While ($true) {
      $CounterSamples = Get-Counter '\Process(*)\ID Process','\Process(*)\% Processor Time','\Process(*)\Working Set' | Select-Object -Expand CounterSamples
      Clear-Host
      $CounterSamples | Group-Object { Split-Path $_.Path } | Where-Object {$_.Group[1].InstanceName -notmatch "^Idle|_Total|System$"} | Sort-Object -Property {$_.Group[1].CookedValue} -Descending | Select-Object -First $TotalList | Format-Table @{Name="ProcessId";Expression={$_.Group[0].CookedValue}},@{Name="ProcessorUsage";Expression={[System.Math]::Round($_.Group[1].CookedValue/100/$env:NUMBER_OF_PROCESSORS,4)}},@{Name="ProcessName";Expression={$_.Group[1].InstanceName}},@{Name="WorkingSet";Expression={[System.Math]::Round($_.Group[2].CookedValue/1MB,4)}}
      Sleep -Seconds $Invertal
    }
  }
  End {}
}

Funkcja opiera się na Get-Counterpróbkach i wyświetli ProcessId,ProcessName,ProcessorUsagei WorkingSet. Ta próbka licznik mógłby być dodatkowo wzmocniona, aby zawierać User, CommandLinena wyjściu, ale nie wypracowaliśmy jeszcze wydajnych sposób to zrobić.

Ten komentarz od Marka powinien otrzymać więcej rekomendacji, ponieważ robi prawie dokładnie to, co było pytaniem i działa:

Zapewnia ładne nagłówki u góry każdej aktualizacji bez konieczności czyszczenia całej konsoli.

$saveY = [console]::CursorTop
$saveX = [console]::CursorLeft      

while ($true) {
    Get-Process | Sort -Descending CPU | Select -First 30;
    Sleep -Seconds 2;
    [console]::setcursorposition($saveX,$saveY+3)
}

(link do komentarza: https://superuser.com/a/770455/989044 )

Powinieneś stworzyć dla niego prosty moduł i umieścić go na github lub dostarczyć mu choco. Myślę, że powinien to być przede wszystkim moduł standardowy, ponieważ jest intensywnie wyszukiwany w google i istnieją różnego rodzaju obejścia, ale żadne z nich nie jest tak eleganckie i bliskie poleceniu linux top.

Przepraszam, że opublikowałem to w ten sposób, ale z powodu obowiązujących tutaj zasad striktu nie można komentować ani robić notatek bez około 50 karmy.

Aby uruchomić top bezpośrednio z cmd, musisz utworzyć plik% WINDIR% \ top.bat z tym kodem:

@echo off && cls && @echo TOP Program initialisation. Please Wait...
powershell -ExecutionPolicy unrestricted -command "& {cls; While(1) {ps | sort -des cpu | select -f 35 | ft -a; sleep 2; cls}}"

Jeśli chcesz filtrować według procesu, użyj findstr

while (1) { ps | findstr explorer | sort -desc cpu | select -first 30; sleep -seconds 2; cls }

Możesz uruchomić monitor zasobów z PowerShell za pomocą:

PS C:\>resmon

Zawsze możesz zamknąć aplikację za pomocą Alt + F4, co powinno przywrócić fokus z powrotem do okna PowerShell.

Możesz spróbować htop-alternatywa dla systemu Windows - NTop

monitor systemowy podobny do htopa z emulacją Vi dla Windows. Ponieważ korzystanie z Menedżera zadań nie jest wystarczająco fajne.

NTop jak w Windows NT-op lub NukeTop. Cokolwiek wolisz (to ostatnie oczywiście).

Opcje wiersza poleceń :

• -C Użyj schematu kolorów monochromatycznych.
• -h Wyświetl informacje pomocy.
• -p PID, PID ... Pokaż tylko podane PID.
• -s KOLUMNA Sortuj według tej kolumny.
• -u NAZWA UŻYTKOWNIKA Wyświetlane są tylko procesy należące do tego użytkownika.
• -v Wersja do wydruku.

Interaktywne polecenia:

• Strzałki w górę i w dół, PgUp i PgDown, j i k Przewiń listę procesów.
• CTRL + strzałka w lewo i w prawo Zmień kolumnę sortowania procesu.
• g Przejdź na górę listy procesów.
• G Idź na dół listy procesów.
• Spacja Oznacz wybrany proces.
• U Odznacz wszystkie oznaczone procesy.
• K Zabij wszystkie oznaczone procesy.
• I odwracam porządek sortowania.
• F Postępuj zgodnie z procesem: jeśli kolejność sortowania powoduje, że aktualnie wybrany proces przesuwa się na liście, ustaw pasek wyboru zgodnie z nim. Ręczne przesuwanie kursora automatycznie wyłącza tę funkcję.
• n Dalej w wyszukiwaniu.
• N Poprzednie wyszukiwanie.

Polecenia Vi :

• : exec CMD Wykonuje podane polecenie systemu Windows.
• : kill PID (s) Zabij wszystkie podane procesy.
• : q ,: quit Zakończ NTop.
• / WZÓR,: szukaj WZÓR Wykonaj wyszukiwanie.
• : sort COLUMN Posortuj listę procesów po danej kolumnie.
• : drzewo Zobacz drzewo procesów.

Wstępnie skompilowane pliki binarne można pobrać tutaj

Zapisz następujące elementy w pliku o nazwie mytop.ps1w folderze, który znajduje się w PATHzmiennej środowiskowej. Następnie użyj jednej z następujących opcji z dowolnej konsoli PowerShell:

1. mytop - aby użyć domyślnego sortowania według kolumny „Pamięć” i wyświetlić pierwsze 30 wierszy.
2. mytop CPU 50 - sortowanie według kolumny „CPU” i wyświetlanie pierwszych 50 wierszy.
3. While(1) {$p = myTop Memory 50; cls; $p} - aby odświeżał się co sekundę.

mytop.ps1 zawartość:

##################################################
#  Linux top equivalent in PowerShell
##################################################
if ($args[0] -eq $null) {
    $SortCol = "Memory"
} else {
    $SortCol = $args[0]    
}

if ($args[1] -eq $null) {
    $Top = 30
} else {
    $Top = $args[1]   
}


$LogicalProcessors = (Get-WmiObject -class Win32_processor `
    -Property NumberOfLogicalProcessors).NumberOfLogicalProcessors;

function myTopFunc ([string]$SortCol = "Memory", [int]$Top = 30) {
    ## Check user level of PowerShell 
    if (
        ([Security.Principal.WindowsPrincipal][Security.Principal.WindowsIdentity]::GetCurrent() 
        ).IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator)
    )
    {
        $procTbl = get-process -IncludeUserName | select ID, Name, UserName, Description, MainWindowTitle
    } else {
        $procTbl = get-process | select ID, Name, Description, MainWindowTitle
    }

    Get-Counter `
        '\Process(*)\ID Process',`
        '\Process(*)\% Processor Time',`
        '\Process(*)\Working Set - Private'`
        -ea SilentlyContinue |
    foreach CounterSamples |
    where InstanceName -notin "_total","memory compression" |
    group { $_.Path.Split("\\")[3] } |
    foreach {
        $procIndex = [array]::indexof($procTbl.ID, [Int32]$_.Group[0].CookedValue)
        [pscustomobject]@{
            Name = $_.Group[0].InstanceName;
            ID = $_.Group[0].CookedValue;
            User = $procTbl.UserName[$procIndex]
            CPU = if($_.Group[0].InstanceName -eq "idle") {
                $_.Group[1].CookedValue / $LogicalProcessors 
                } else {
                $_.Group[1].CookedValue 
                };
            Memory = $_.Group[2].CookedValue / 1KB;
            Description = $procTbl.Description[$procIndex];
            Title = $procTbl.MainWindowTitle[$procIndex];
        }
    } |
    sort -des $SortCol |
    select -f $Top @(
        "Name", "ID", "User",
        @{ n = "CPU"; e = { ("{0:N1}%" -f $_.CPU) } },
        @{ n = "Memory"; e = { ("{0:N0} K" -f $_.Memory) } },
        "Description", "Title"
        ) | ft -a
}

myTopFunc -SortCol $SortCol -top $Top

Przykładowe dane wyjściowe:

Name                               ID User                         CPU   Memory       Description
----                               -- ----                         ---   ------       -----------
sqlservr                         7776 NT SERVICE\MSSQLSERVER       0.0%  19,001,488 K SQL Server Windows NT - 64 Bit
python                          12872 NA\user1                     0.0%  2,159,796 K  Python
svchost                          3328 NT AUTHORITY\SYSTEM          1.6%  1,022,080 K  Host Process for Windows Services
onedrive                        11872 NA\user1                     0.0%  423,396 K    Microsoft OneDrive
python                          13764 NA\user1                     0.0%  304,608 K    Python
chrome                          21188 NA\user1                     0.0%  250,624 K    Google Chrome
python                          28144 NA\user2                     0.0%  225,824 K    Python
code                            21384 NA\user1                     0.0%  211,160 K    Visual Studio Code
code                            27412 NA\user2                     0.0%  185,892 K    Visual Studio Code
ssms                            18288 NA\user1                     29.5% 155,452 K    SSMS
chrome                           7536 NA\user1                     0.0%  154,124 K    Google Chrome
code                            21652 NA\user1                     0.0%  149,900 K    Visual Studio Code
explorer                         3204 NA\user1                     0.0%  134,340 K    Windows Explorer
python                          11712 NA\user1                     0.0%  130,624 K    Python
chrome                          21588 NA\user1                     0.0%  107,448 K    Google Chrome
code                            10152 NA\user1                     0.0%  100,880 K    Visual Studio Code
code                            20232 NA\user2                     0.0%  99,124 K     Visual Studio Code
python                          22184 NA\user1                     0.0%  94,800 K     Python
code                            14828 NA\user1                     0.0%  84,872 K     Visual Studio Code
searchui                        13344 NA\user1                     0.0%  78,260 K     Search and Cortana application
com.docker.service              10644 NT AUTHORITY\SYSTEM          0.0%  77,332 K     Docker.Service

Dodatkowy kredyt dla:

1. rokumaru dla https://stackoverflow.com/a/55698377/5060792
2. LotPings dla https://stackoverflow.com/a/55680398/5060792
3. DBADon dla https://stackoverflow.com/a/55697007/5060792

Na coś jeszcze należy spojrzeć:

https://docs.microsoft.com/en-us/sysinternals/downloads/process-utilities

Istnieje narzędzie wiersza polecenia, aby zrzucić wszystkie procesy (i oczywiście Process Monitor lub Process Explorer).

Użyj poniższego polecenia, aby uzyskać najlepsze wykorzystanie procesora 10, a dane wyjściowe będą odświeżane co 5 sekund

while (1) {ps | Sort-Object -Property cpu -Descending | wybierz -Pierwszy 10; Wyjście Host-Zapis "zostanie odświeżone za 5 sekund nn Uchwyty NPM (K) PM (K) WS (K) CPU (s) Id SI ProcessName"; spać - Sekundy 5}