Jak uzyskać liczbę procesorów / rdzeni w systemie Linux z wiersza polecenia?


540

Mam ten skrypt, ale nie wiem, jak uzyskać ostatni element na wydruku:

cat /proc/cpuinfo | awk '/^processor/{print $3}'

Ostatnim elementem powinna być liczba procesorów minus 1.


9
Nie trzeba się catwcześniej awk, i tak: po prostu awk '<script>' /proc/cpuinfo, tak: awk '/^processor/{n+=1}END{print n}' /proc/cpuinfo. I wchodzisz bez „minus jeden”.
Tomasz Gandor

Aby bezpośrednio odpowiedzieć na pytanie, przeciągnij do tego, tail -n 1który pobiera ostatni wiersz i drukuje go.
Fábio Santos,

Odpowiedzi:


659
grep -c ^processor /proc/cpuinfo     

policzy liczbę linii zaczynających się od „procesor” w /proc/cpuinfo

W przypadku systemów z hiperwątkowością można użyć

grep ^cpu\\scores /proc/cpuinfo | uniq |  awk '{print $4}' 

który powinien zwrócić (na przykład) 8(podczas gdy powyższe polecenie powróci 16)


42
Zauważ, że oba te kończą licząc dwa razy więcej rdzeni, niż faktycznie istnieją, jeśli korzystasz z systemu z hyperthreading (np. P4 lub Core i7).
duskwuff -inactive-

24
@duskwuff: to jest dokładnie to, czego chcesz w większości przypadków.
Frank Kusters

8
grep -c '^processor' /proc/cpuinfona Zsh.
Steven Lu

40
cat /proc/cpuinfo | awk '/^processor/{print $3}' | tail -1zwróci również nieprawidłowy numer, jeśli numery procesorów są oparte na 0.
Phazor

3
Pierwsza linia zwraca 1 rdzeń mniej niż istnieje. Better cat / proc / cpuinfo | awk '/ ^ procesor / {print $ 3}' | wc -l
Mirko Ebert

649

Przetwarzanie zawartości /proc/cpuinfojest niepotrzebnie barokowe. Użyj nproc, który jest częścią coreutils, więc powinien być dostępny w większości instalacji Linuksa.

Polecenie nprocdrukuje liczbę jednostek przetwarzania dostępnych dla bieżącego procesu, która może być mniejsza niż liczba procesorów online.

Aby znaleźć liczbę wszystkich zainstalowanych rdzeni / procesorów, użyj nproc --all

Na mojej 8-rdzeniowej maszynie:

$ nproc --all
8

8
czy rozróżnia rdzeń wirtualny od fizycznego?
Richard

12
Nie działa to w przypadku hiperwątkowania, jeśli potrzebuję liczby rdzeni fizycznych. Zwraca 8 w moim pudełku z czterordzeniowym komputerem i7.
pratnala

1
@pratnala - odpowiedź teambob podaje liczbę rdzeni fizycznych.
Nick Chammas,

1
Na moim starym Ubuntu (10.10) nproc nie jest dostępny. To musi być nowy dodatek.
bukzor

3
Niestety nprocnie jest częścią boot2docker
kgadek

269

Najbardziej przenośnym rozwiązaniem, jakie znalazłem, jest getconfpolecenie:

getconf _NPROCESSORS_ONLN

Działa to zarówno w systemie Linux, jak i Mac OS X. Inną zaletą tego w porównaniu z innymi podejściami jest to, że getconf istnieje już od dłuższego czasu. Niektóre starsze maszyny z Linuksem, na których muszę tworzyć, nie mają dostępnych poleceń nproclub lscpu, ale mają getconf.

Od redakcji: Podczas narzędzie jest upoważniona POSIX , specyficzne i wartości nie są. To powiedziawszy, jak powiedziano, działają na platformach Linux, a także na macOS; na FreeBSD / PC-BSD musisz pominąć wiodącą pozycję .getconf _NPROCESSORS_ONLN_NPROCESSORS_CONF _


11
Działa to dla mnie w Red Hat Entreprise Linux 5.4, Centos 6.5 i 7 oraz Mac OSX 10.9 (Mavericks). Wygląda na to, że jest najbardziej przenośny, ponieważ lscpu nie jest domyślnie instalowany w tych systemach. Dzięki!
big_gie

1
Zgadzam się. To jest dość przenośne.
bukzor


1
@BCran Nie mogłem znaleźć _NPROCESSORS_ONLNw POSIX. Czy możesz do niego link?
Ciro Santilli 郝海东 冠状 病 六四 事件 法轮功

3
@CiroSantilli 六四 事件 法轮功 纳米比亚 威 视 Z github.com/gstrauss/plasma/blob/master/plasma_sysconf.c wygląda na to, że się myliłem: jest to opcjonalne. „sysconf _SC_NPROCESSORS_ONLN i _SC_NPROCESSORS_CONF nie są wymagane przez standardy, ale są dostarczane na wielu platformach unix i udokumentowane jako opcjonalne przez Open Group.”
BCran,

100

Przedmowa:

  • Problem z /proc/cpuinfoopartych o odpowiedziach jest to, że parse informacje, które było przeznaczone dla ludzkiej konsumpcji, a tym samym brakuje formatu stabilne przeznaczone do maszynowego parsowania : Format wyjściowy może się różnić na różnych platformach i warunków wykonawczych; używanie lscpu -pw systemie Linux (i sysctlmacOS) omija ten problem .

  • getconf _NPROCESSORS_ONLN/ getconf NPROCESSORS_ONLNNie rozróżnia logicznych i fizycznych procesorów.


Oto shfragment kodu (zgodny z POSIX), który działa w systemach Linux i macOS do określania liczby procesorów logicznych lub fizycznych w trybie online ; zobacz komentarze, aby uzyskać szczegółowe informacje.

Korzysta lscpuz systemu Linux i sysctlmacOS.

Uwaga dotycząca terminologii : CPU oznacza najmniejszą jednostkę przetwarzającą widzianą przez system operacyjny. Każdy rdzeń niebędący hiperwątkiem odpowiada 1 procesorowi, podczas gdy rdzenie hiperwątkowujące zawierają więcej niż 1 (zwykle: 2) - logicznie - procesor.
Linux wykorzystuje następującą taksonomię [1] , zaczynając od najmniejszej jednostki:
CPU < rdzeń < gniazdo < książka < węzeł
z każdym poziomem zawierającym 1 lub więcej instancji następnego niższego poziomu.

#!/bin/sh

# macOS:           Use `sysctl -n hw.*cpu_max`, which returns the values of 
#                  interest directly.
#                  CAVEAT: Using the "_max" key suffixes means that the *maximum*
#                          available number of CPUs is reported, whereas the
#                          current power-management mode could make *fewer* CPUs 
#                          available; dropping the "_max" suffix would report the
#                          number of *currently* available ones; see [1] below.
#
# Linux:           Parse output from `lscpu -p`, where each output line represents
#                  a distinct (logical) CPU.
#                  Note: Newer versions of `lscpu` support more flexible output
#                        formats, but we stick with the parseable legacy format 
#                        generated by `-p` to support older distros, too.
#                        `-p` reports *online* CPUs only - i.e., on hot-pluggable 
#                        systems, currently disabled (offline) CPUs are NOT
#                        reported.

# Number of LOGICAL CPUs (includes those reported by hyper-threading cores)
  # Linux: Simply count the number of (non-comment) output lines from `lscpu -p`, 
  # which tells us the number of *logical* CPUs.
logicalCpuCount=$([ $(uname) = 'Darwin' ] && 
                       sysctl -n hw.logicalcpu_max || 
                       lscpu -p | egrep -v '^#' | wc -l)

# Number of PHYSICAL CPUs (cores).
  # Linux: The 2nd column contains the core ID, with each core ID having 1 or
  #        - in the case of hyperthreading - more logical CPUs.
  #        Counting the *unique* cores across lines tells us the
  #        number of *physical* CPUs (cores).
physicalCpuCount=$([ $(uname) = 'Darwin' ] && 
                       sysctl -n hw.physicalcpu_max ||
                       lscpu -p | egrep -v '^#' | sort -u -t, -k 2,4 | wc -l)

# Print the values.
cat <<EOF
# of logical CPUs:  $logicalCpuCount
# of physical CPUS: $physicalCpuCount
EOF

[1] dokumentacja macOSsysctl (3)

Zauważ, że systemy pochodzące z BSD inne niż macOS - np. FreeBSD - obsługują tylko hw.ncpuklucz dla sysctl, które są przestarzałe w macOS; Jestem jasne, która z nowych kluczy hw.npuodpowiada: hw.(logical|physical)cpu_[max].

Wskazówka dla @teambob za pomoc w poprawieniu lscpukomendy obliczania fizycznych procesorów .

Uwaga : lscpu -pdane wyjściowe NIE zawierają kolumny „książka” ( manstrona wspomina o „książkach” jako encji między gniazdem a węzłem w hierarchii taksonomicznej). Jeśli „książki” są w grze w danym systemie Linux ( czy ktoś wie kiedy i jak? ), Komenda fizyko-CPU-count może pod -report (ta opiera się na założeniu, że lscpuraporty identyfikatory, które są specyficzne dla całej wyższy -poziomowe jednostki , np .: 2 różne rdzenie z 2 różnych gniazd mogą mieć ten sam identyfikator).


Jeśli zapiszesz powyższy kod jako, powiedzmy, skrypt powłokicpus , sprawisz , że będzie wykonywalny chmod +x cpusi umieścisz go w folderze w swoim folderze $PATH, zobaczysz dane wyjściowe, takie jak:

$ cpus
logical  4
physical 4

[1] Xaekai rzuca światło na to, czym jest książka : „ książka to moduł zawierający płytkę drukowaną z gniazdami procesora, gniazdami RAM, połączeniami IO wzdłuż krawędzi i hakiem do integracji systemu chłodzenia. Są one używane w komputerach mainframe IBM Więcej informacji: http://ewh.ieee.org/soc/cpmt/presentations/cpmt0810a.pdf


1
Tak, przepraszam, masz rację co do polecenia sortowania. Nie mogę znaleźć żadnych informacji o książkach poza instrukcją lscpu. Myślę, że jest to związane z NUMA en.wikipedia.org/wiki/Non-uniform_memory_access
teambob 30.04.2014

2
Myślę, że większość rozwiązań tutaj ignoruje maszyny z wieloma gniazdami, w przeciwieństwie do tej. Dzięki!
dividebyzero

1
Pod względem linuksa istnieje wiele kontekstów, w których lscpu jest niedostępne, na przykład obrazy instalatora. Podoba mi się .. chciałbym, żeby były wszechobecne.
Brian Chrisman,

43

lscpu gromadzi informacje o architekturze procesora / proc / cpuinfon w formacie czytelnym dla człowieka:

# lscpu


Architecture:          x86_64
CPU op-mode(s):        32-bit, 64-bit
Byte Order:            Little Endian
CPU(s):                8
On-line CPU(s) list:   0-7
Thread(s) per core:    1
Core(s) per socket:    4
CPU socket(s):         2
NUMA node(s):          1
Vendor ID:             GenuineIntel
CPU family:            6
Model:                 15
Stepping:              7
CPU MHz:               1866.669
BogoMIPS:              3732.83
Virtualization:        VT-x
L1d cache:             32K
L1i cache:             32K
L2 cache:              4096K
NUMA node0 CPU(s):     0-7

Zobacz także /unix/468766/understanding-output-of-lscpu .


13

To zadziałało dla mnie. tail -nXpozwala uchwycić tylko ostatnie X linii.

cat /proc/cpuinfo | awk '/^processor/{print $3}' | tail -1

Jeśli masz hyperthreading, powinno to działać w celu pobrania liczby rdzeni fizycznych .

grep "^core id" /proc/cpuinfo | sort -u | wc -l

1
jest „^ core id” dla wszystkich rdzeni fizycznych lub tylko rdzeni p na jednym procesorze?
Richard

1
istnieje jeden wiersz identyfikatora rdzenia na unikalny fizyczny rdzeń w systemie. Nie wiem jednak, czy liczby zaczną się od zera dla drugiego procesora fizycznego, jednak ...
lunixbochs

1
jeśli masz więcej niż jeden procesor fizyczny, musisz także spojrzeć na „identyfikator fizyczny”.
Anne,

Pierwsza linia nie działała dla mnie. To działa dla mnie. cat /proc/cpuinfo | awk '/^processor/{print $3}'| wc -li pokazuje prawidłową liczbę.
jaylweb

11

Dla całkowitej liczby rdzeni fizycznych:

grep '^core id' /proc/cpuinfo |sort -u|wc -l

Na maszynach z wieloma gniazdami (lub zawsze) należy pomnożyć powyższy wynik przez liczbę gniazd:

echo $(($(grep "^physical id" /proc/cpuinfo | awk '{print $4}' | sort -un | tail -1)+1))

@ mklement0 ma całkiem fajną odpowiedź poniżej za pomocą lscpu. W komentarzach napisałem bardziej zwięzłą wersję


10

Możesz także użyć Pythona! Aby uzyskać liczbę rdzeni fizycznych:

$ python -c "import psutil; print(psutil.cpu_count(logical=False))"
4

Aby uzyskać liczbę rdzeni hiperwątkowych:

$ python -c "import psutil; print(psutil.cpu_count(logical=True))"
8

W Pythonie 2.7.15 te polecenia nic nie drukują. W REPL tak.
Vytenis Bivainis,

1
@VytenisBivainis Dzięki, naprawiłem swoją odpowiedź!
ostrokach

9

Rozwiązanie Crossplatform dla systemów Linux, MacOS, Windows:

CORES=$(grep -c ^processor /proc/cpuinfo 2>/dev/null || sysctl -n hw.ncpu || echo "$NUMBER_OF_PROCESSORS")

9

Oto sposób, w jaki używam do zliczania liczby rdzeni fizycznych, które są online w systemie Linux:

lscpu --online --parse=Core,Socket | grep --invert-match '^#' | sort --unique | wc --lines

lub w skrócie:

lscpu -b -p=Core,Socket | grep -v '^#' | sort -u | wc -l

Przykład (1 gniazdo):

> lscpu
...
CPU(s):                28
Thread(s) per core:    2
Core(s) per socket:    14
Socket(s):             1
....
> lscpu -b -p=Core,Socket | grep -v '^#' | sort -u | wc -l
14

Przykład (2 gniazda):

> lscpu
...
CPU(s):                56
Thread(s) per core:    2
Core(s) per socket:    14
Socket(s):             2
...
> lscpu -b -p=Core,Socket | grep -v '^#' | sort -u | wc -l
28

Przykład (4 gniazda):

> lscpu
...
CPU(s):                64
Thread(s) per core:    2
Core(s) per socket:    8
Socket(s):             4
...
> lscpu -b -p=Core,Socket | grep -v '^#' | sort -u | wc -l
32

Działa i obsługuje wiele gniazd
jbo5112

To najlepsza odpowiedź.
Jorma Rebane

7

Korzystanie z getconf jest rzeczywiście najbardziej przenośnym sposobem, jednak zmienna ma różne nazwy w BSD i Linux, aby uzyskać getconf, więc musisz przetestować oba, jak sugeruje to gist: https://gist.github.com/jj1bdx/5746298 (obejmuje również poprawka Solaris za pomocą ksh)

Osobiście używam:

$ getconf _NPROCESSORS_ONLN 2>/dev/null || getconf NPROCESSORS_ONLN 2>/dev/null || echo 1

A jeśli chcesz tego w pythonie, możesz po prostu użyć syscall, którego używa getconf, importując moduł os:

$ python -c 'import os; print os.sysconf(os.sysconf_names["SC_NPROCESSORS_ONLN"]);'

Co do tego nproc, jest częścią GNU Coreutils, więc domyślnie nie jest dostępna w BSD. Używa sysconf () również po kilku innych metodach.


6

Jeśli chcesz to zrobić, aby działało na systemie Linux i OS X, możesz:

CORES=$(grep -c ^processor /proc/cpuinfo 2>/dev/null || sysctl -n hw.ncpu)

W moim przypadku zwraca liczbę hiperwątków. Musiałbym także znać liczbę fizycznych rdzeni i liczbę gniazd.
user2465201,

OK - dokładnie to samo polecenie z hw.physicalcpu zwraca liczbę rdzeni. Nie jestem pewien co do liczby gniazd ... Istnieje również „logiczna” i „aktywna” liczba procesorów, ale nie jestem pewien, co to oznacza.
user2465201,

Szybka aktualizacja - nie wydaje się taka przenośna. Wypróbowałem to na Linux-ie i wygląda na to, że po prostu czytam katalogi / proc, które różnią się w systemie Linux niż Mac - na przykład nie ma podkatalogu hw. To powiedziawszy, wciąż możesz
parsować


3

Możesz użyć jednej z następujących metod, aby określić liczbę fizycznych rdzeni procesora.

  • Policz liczbę unikalnych podstawowych identyfikatorów (mniej więcej tyle, ile wynosi grep -P '^core id\t' /proc/cpuinfo | sort -u | wc -l).

    awk '/^core id\t/ {cores[$NF]++} END {print length(cores)}' /proc/cpuinfo

  • Pomnóż liczbę „rdzeni na gniazdo” przez liczbę gniazd.

    lscpu | awk '/^Core\(s\) per socket:/ {cores=$NF}; /^Socket\(s\):/ {sockets=$NF}; END{print cores*sockets}'

  • Policz liczbę unikalnych logicznych procesorów używanych przez jądro Linuksa. -pOpcja generuje wyjście dla łatwego analizowania i jest kompatybilny z wcześniejszymi wersjami lscpu.

    lscpu -p | awk -F, '$0 !~ /^#/ {cores[$1]++} END {print length(cores)}'


Aby powtórzyć to, co powiedzieli inni, istnieje wiele powiązanych właściwości.

Aby określić liczbę dostępnych procesorów:

getconf _NPROCESSORS_ONLN
grep -cP '^processor\t' /proc/cpuinfo

Aby określić liczbę dostępnych jednostek przetwarzających (niekoniecznie taką samą jak liczba rdzeni). Jest to świadomy hipertekstu.

nproc

Nie chcę schodzić zbyt daleko w dół do króliczej nory, ale można również określić liczbę skonfigurowanych procesorów (w przeciwieństwie do zwykłych procesorów dostępnych online) getconf _NPROCESSORS_CONF. Aby określić całkowitą liczbę procesorów (offline i online), należy przeanalizować dane wyjściowe lscpu -ap.


to poprawna odpowiedź, jeśli chcesz mieć rdzenie fizyczne.
Dinesh

3

Pomyślałem również, cat /proc/cpuinfoże da mi poprawną odpowiedź, jednak ostatnio zauważyłem, że mój czterordzeniowy system ARM Cortex A53 wykazywał tylko jeden rdzeń. Wygląda na to, że / proc / cpuinfo pokazuje tylko aktywne rdzenie, podczas gdy:

cat /sys/devices/system/cpu/present

jest lepszą miarą tego, co tam jest. Możesz też

cat /sys/devices/system/cpu/online

aby zobaczyć, które rdzenie są online, i

cat /sys/devices/system/cpu/offline

aby zobaczyć, które rdzenie są offline. Te online, offlineoraz presentSysFS wpisy powrót indeksu jednostek CPU, a więc wartość powrotu 0tylko środki rdzenia 0, podczas gdy wartość powrotną 1-3oznacza, że rdzenie 1,2 i 3.

Zobacz https://www.kernel.org/doc/Documentation/ABI/testing/sysfs-devices-system-cpu


2

Poniższe informacje powinny dać ci liczbę „prawdziwych” rdzeni zarówno w systemie hiperwątkowym, jak i niehththreaded. Przynajmniej działał we wszystkich moich testach.

awk -F: '/^physical/ && !ID[$2] { P++; ID[$2]=1 }; /^cpu cores/ { CORES=$2 };  END { print CORES*P }' /proc/cpuinfo

-1, to wraca 0na jednym rdzeniu z Opteron 4170 HE, ale wraca 4na ośmiordzeniowym pudełku z Opteron 3280. ... część mnie naprawdę życzy sobie, aby ten liner działał!
zamnuts,

1

Nie moja strona internetowa, ale to polecenie z http://www.ixbrian.com/blog/?p=64&cm_mc_uid=89402252817914508279022&cm_mc_sid_50200000=1450827902 działa dla mnie ładnie na centos. Pokaże rzeczywisty procesor, nawet gdy włączony jest hiperwątkowanie.

cat /proc/cpuinfo | egrep "core id|physical id" | tr -d "\n" | sed s/physical/\\nphysical/g | grep -v ^$ | sort | uniq | wc -l


+1, dłużej niż rozwiązanie z „lscpu -p = Core, Socket”, ale działa bezpośrednio podczas analizowania / proc / cpuinfo, bez potrzeby lscpu.
Fravadona,

1

Policz „identyfikator rdzenia” według metody „identyfikatora fizycznego” za pomocą awk z rezerwą na „procesorze”, licz, jeśli „identyfikator rdzenia” nie jest dostępny (np. Malina)

echo $(awk '{ if ($0~/^physical id/) { p=$NF }; if ($0~/^core id/) { cores[p$NF]=p$NF }; if ($0~/processor/) { cpu++ } } END { for (key in cores) { n++ } } END { if (n) {print n} else {print cpu} }' /proc/cpuinfo)

1
cat /proc/cpuinfo | grep processor

To działało dobrze. Kiedy wypróbowałem pierwszą odpowiedź, otrzymałem 3 procesory jako dane wyjściowe. Wiem, że mam 4 procesory w systemie, więc właśnie zrobiłem grepprocesor, a dane wyjściowe wyglądały następująco:

[root@theservername ~]# cat /proc/cpuinfo | grep processor
processor       : 0
processor       : 1
processor       : 2
processor       : 3

1
 dmidecode  | grep -i cpu | grep Version

daje mi

Wersja: Intel (R) Xeon (R) CPU E5-2667 v4 @ 3.20GHz

Wersja: Intel (R) Xeon (R) CPU E5-2667 v4 @ 3.20GHz

Która jest poprawna liczba gniazd - patrząc w górę E5-2667mówi mi, że każde gniazdo ma 8 cores, więc pomnóż i skończ z 16 coresprzecinkiem 2 sockets.

Gdzie lscpudaj mi 20 CPUs- co jest całkowicie niepoprawne - nie jestem pewien, dlaczego. (to samo dotyczy cat /proc/cpu- kończy się na 20.


1

Szybszy, bez widelca

Działa to z prawie wszystkimi .

ncore=0
while read line ;do
    [ "$line" ] && [ -z "${line%processor*}" ] && ncore=$((ncore+1))
  done </proc/cpuinfo
echo $ncore
4

Aby zachować zgodność z , , i inne, których użyłem ncore=$((ncore+1))zamiast ((ncore++)).

wersja

ncore=0
while read -a line ;do
    [ "$line" = "processor" ] && ((ncore++))
  done </proc/cpuinfo
echo $ncore
4

Ten post jest powiązany z odpowiedzią na ciąg znaków w Bash !
F. Hauri

1

Jeśli możesz używać Pythona, numexprmoduł ma do tego funkcję:

In [5]: import numexpr as ne

In [6]: ne.detect_number_of_cores()
Out[6]: 8

także to:

In [7]: ne.ncores
Out[7]: 8

Aby wyszukać te informacje w wierszu polecenia, użyj:

# runs whatever valid Python code given as a string with `-c` option
$ python -c "import numexpr as ne; print(ne.ncores)"
8

Lub po prostu można uzyskać te informacje z multiprocessing.cpu_count()funkcji

$ python -c "import multiprocessing; print(multiprocessing.cpu_count())"

Lub jeszcze bardziej po prostu użyj os.cpu_count()

$ python -c "import os; print(os.cpu_count())"

1
Czy istnieje sposób, aby to działało jako polecenie w Pythonie? Na przykład próbowałem python -m numexpr.ncores, ale to nie działa.
MonsieurBeilto

1
@MonsieurBeilto Proszę spojrzeć na zaktualizowaną odpowiedź!
kmario23

Zwracana liczba cpu_countjest niepoprawna, nie zwraca liczby rdzeni, a jedynie liczbę hiperwątków na procesorach Intela
Antti Haapala

1

Jeśli chcesz policzyć rdzenie fizyczne, to polecenie zrobiło to dla mnie.

lscpu -e | tail -n +2 | tr -s " " | cut -d " " -f 4 | sort | uniq | wc -w

Całkiem proste, ale zdaje się liczyć rzeczywiste rdzenie fizyczne, ignorując logiczną liczbę


0

Python 3 oferuje również kilka prostych sposobów na uzyskanie:

$ python3 -c "import os; print(os.cpu_count());"

4

$ python3 -c "import multiprocessing; print(multiprocessing.cpu_count())"

4


To zwraca mi 8, gdy mam 4 rdzenie z 2 wątkami na każdym ...
Antti Haapala

0

Użyj poniższego zapytania, aby uzyskać podstawowe informacje

[oracle@orahost](TESTDB)$ grep -c ^processor /proc/cpuinfo
8

0

Podsumowanie: aby uzyskać fizyczne procesory, wykonaj następujące czynności:

grep 'core id' /proc/cpuinfo | sort -u

aby uzyskać fizyczne i logiczne procesory, wykonaj następujące czynności:

grep -c ^processor /proc/cpuinfo

/proc << to jest złote źródło wszelkich potrzebnych informacji na temat procesów i

/proc/cpuinfo << jest złotym źródłem wszelkich informacji o procesorze.


Fizyczne liczenie procesora nie działa na komputerach z wieloma gniazdami; w tym celu należy powiązać każdy „identyfikator rdzenia” z jego „identyfikatorem fizycznym”.
Fravadona,
Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.