Chciałem dowiedzieć się, ile rdzeni ma mój system, więc szukałem tego samego pytania w Google. Mam kilka poleceń, takich jak lscpupolecenie. Po wypróbowaniu tego polecenia otrzymałem następujący wynik:

$ lscpu
Architecture:          x86_64
CPU op-mode(s):        32-bit, 64-bit
Byte Order:            Little Endian
CPU(s):                4
On-line CPU(s) list:   0-3
Thread(s) per core:    1
Core(s) per socket:    4
Socket(s):             1
NUMA node(s):          1
Vendor ID:             GenuineIntel
CPU family:            6
Model:                 23
Stepping:              10
CPU MHz:               1998.000
BogoMIPS:              5302.48
Virtualization:        VT-x
L1d cache:             32K
L1i cache:             32K
L2 cache:              2048K
NUMA node0 CPU(s):     0-3

W szczególności dane wyjściowe pokazują:

• Procesory: 4
• Rdzeń na gniazdo: 4
• Rodzina procesorów: 6

Który z nich wskazuje rdzenie systemu Linux?

Czy jest jakieś inne polecenie określające liczbę rdzeni, czy też zakładam, że jest całkowicie błędne?

Musisz spojrzeć na gniazda i rdzenie na gniazdo. W tym przypadku masz 1 fizyczny procesor (gniazdo), który ma 4 rdzenie (rdzenie na gniazdo).

Aby uzyskać pełny obraz, musisz spojrzeć na liczbę wątków na rdzeń, rdzenie na gniazdo i gniazda . Jeśli pomnożycie te liczby, otrzymacie liczbę procesorów w systemie.

Procesory = liczba wątków na rdzeń X rdzeni na gniazdo X gniazda

Procesory są tym, co widać po uruchomieniu htop(nie są równe procesorom fizycznym).

Oto przykład z komputera stacjonarnego:

$ lscpu | grep -E '^Thread|^Core|^Socket|^CPU\('
CPU(s):                8
Thread(s) per core:    2
Core(s) per socket:    4
Socket(s):             1

I serwer:

$ lscpu | grep -E '^Thread|^Core|^Socket|^CPU\('
CPU(s):                32
Thread(s) per core:    2
Core(s) per socket:    8
Socket(s):             2

Wyjście nprocodpowiada liczbie procesorów od lscpu. W przypadku komputera stacjonarnego powyżej powinno to być 8 procesorów zgłoszonych przez lscpu:

$ nproc --all
8

Dane wyjściowe /proc/cpuinfopowinny pasować do tych informacji, na przykład w powyższym systemie stacjonarnym widać, że jest 8 procesorów (procesorów) i 4 rdzenie (identyfikator rdzenia 0-3):

$ grep -E 'processor|core id' /proc/cpuinfo
processor   : 0
core id     : 0
processor   : 1
core id     : 0
processor   : 2
core id     : 1
processor   : 3
core id     : 1
processor   : 4
core id     : 2
processor   : 5
core id     : 2
processor   : 6
core id     : 3
processor   : 7
core id     : 3

cpu coresDonosi /proc/cpuinfoodpowiada Core(s) per socketdonosi lscpu. W przypadku komputera stacjonarnego powyżej powinno to odpowiadać 4 rdzeniom na gniazdo zgłoszonym przez lscpu:

$ grep -m 1 'cpu cores' /proc/cpuinfo
cpu cores   : 4

Aby dokładnie odpowiedzieć na twoje pytanie, powiedz, ile masz rdzeni, mnożąc liczbę rdzeni na gniazdo przez liczbę gniazd.

Rdzenie = Rdzenie na gniazdo X Gniazda

Na przykładowe systemy powyżej pulpitu mają 4 rdzenie:

$ echo "Cores = $(( $(lscpu | awk '/^Socket\(s\)/{ print $2 }') * $(lscpu | awk '/^Core\(s\) per socket/{ print $4 }') ))"
Cores = 4

Podczas gdy serwer ma 16:

$ echo "Cores = $(( $(lscpu | awk '/^Socket\(s\)/{ print $2 }') * $(lscpu | awk '/^Core\(s\) per socket/{ print $4 }') ))"
Cores = 16

Innym przydatnym narzędziem jest to, dmidecodektóre dane wyjściowe przypadają na gniazdo. W przypadku wyżej wymienionego systemu serwerów oczekujemy 8 rdzeni na gniazdo i 16 wątków na gniazdo:

$ sudo dmidecode -t 4 | grep -E 'Socket Designation|Count'
    Socket Designation: CPU1
    Core Count: 8
    Thread Count: 16
    Socket Designation: CPU2
    Core Count: 8
    Thread Count: 16

lscpuKomenda posiada wiele przydatnych opcji, które może chcesz sprawdzić, na przykład:

$ lscpu --all --extended
$ lscpu --all --parse=CPU,SOCKET,CORE | grep -v '^#'

Zobacz man lscpuszczegóły.

W podsumowaniu:

• Musisz być świadomy gniazd, rdzeni i gwintów
• Musisz być ostrożnym z terminem „CPU”, ponieważ oznacza różne rzeczy w różnych kontekstach

Możesz uzyskać te informacje za pomocą nproc(1)polecenia

$ nproc --all
12

Nie wymaga uprawnień roota.

Aby odpowiedź nie była myląca, musisz zrozumieć kilka prostych koncepcji architektury komputerowej:

• Uruchamiasz procesy („programy”) w systemie Linux. Każdy proces składa się z jednego lub więcej wątków
• Każdy wątek to osobna sekwencja instrukcji . Dwa wątki mogą być wykonywane równolegle.
• Każda instrukcja jest przekazywana do procesora, który ma zostać wykonany. Procesor ma logikę, która objaśnia znaczenie bitów instrukcji i decyduje, co z nią zrobić.

• Istnieją różne rodzaje instrukcji. Logika decyzyjna wewnątrz CPU wysyła różne instrukcje do różnych jednostek sprzętowych . Na przykład instrukcje arytmetyczne są w rzeczywistości wykonywane przez ALU (jednostkę arytmetyczną / logiczną), podczas gdy instrukcje ładujące / przechowujące z pamięci są wykonywane przez jakąś jednostkę pamięci .

• Rdzeń odnosi się do zestawu sprzętu rzeczywistego wykonania (czyli każdy rdzeń ma ALU, jednostkę pamięci, etc ...)

• Możesz mieć wiele procesorów, które współużytkują jeden rdzeń - nazywa się to hyperthreading.

  • Pomysł: wątek A obecnie wykonuje arytmetykę, podczas gdy wątek B ładuje coś z pamięci. Gdy jest to prawda, wątki A i B mogą efektywnie współdzielić jeden rdzeń bez wchodzenia sobie w drogę (A używa ALU, B używa jednostki pamięci). Oczywiście czasami oba programy będą chciały ALU, a następnie będą musiały na siebie czekać ...

• Gniazdo jest fizyczne szczelina na płycie głównej, w którym układ scalony jest umieszczony. Ten układ ma pewną liczbę rdzeni.

Przykłady:

Przykład PO:

CPU(s):                4
Thread(s) per core:    1
Core(s) per socket:    4
Socket(s):             1

• jedno fizyczne gniazdo, które zawiera układ z
• 4 rdzenie fizyczne (łącznie 4 ALU i 4 jednostki pamięci)
• Tylko 1 wątek może wydawać instrukcje do rdzenia (bez hipertekstu), co oznacza, że ​​jest
• jeden procesor na rdzeń lub 4 * 1 = 4 procesory

Inny przykład:

CPU(s):                16
Thread(s) per core:    2
Core(s) per socket:    4
Socket(s):             2

Dwa fizyczne gniazda, każde zawierające układ z 4 fizycznymi rdzeniami, co daje w sumie 8 rdzeni. Dwa wątki wysyłają instrukcje do każdego rdzenia (ta maszyna ma hyperthreading), co oznacza, że ​​do każdego rdzenia muszą być podłączone dwa procesory, co daje łącznie 8 * 2 = 16 procesorów

Pierwsza maszyna może wykonywać dokładnie cztery instrukcje w danym momencie i okresie. Druga maszyna może wykonać od 8 do 16 instrukcji w dowolnym momencie: 16 zostanie osiągnięte tylko wtedy, gdy każda para procesorów wykonuje różne typy instrukcji, dzięki czemu może współdzielić rdzeń bez czekania.

Możesz także użyć polecenia, cat /proc/cpuinfoktóre wyświetli porcję danych dla każdego rdzenia. Każda porcja zaczyna się od tych informacji:

processor   : 3
vendor_id   : GenuineIntel
cpu family  : 6
model       : 60
model name  : Intel(R) Core(TM) i5-4210M CPU @ 2.60GHz
(...)

Rdzenie są numerowane od 0, więc jeśli ostatnia porcja mówi processor : 3tak jak w tym przypadku, twoja maszyna ma 4 rdzenie.

getconf _NPROCESSORS_ONLN

(getconf jest częścią glibc)

[root@xxxxx ~]#  dmidecode -t 4 | egrep -i "Designation|Intel|core|thread"
    Socket Designation: CPU1
    Manufacturer: Intel
            HTT (Multi-threading)
    Version: Intel(R) Xeon(R) CPU           L5640  @ 2.27GHz
    Core Count: 6
    Core Enabled: 6
    Thread Count: 12
    Socket Designation: CPU2
    Manufacturer: Intel
            HTT (Multi-threading)
    Version: Intel(R) Xeon(R) CPU           L5640  @ 2.27GHz
    Core Count: 6
    Core Enabled: 6
    Thread Count: 12

$ grep -c processor /proc/cpuinfo
8

To wszystko czego potrzebujesz. Jest to liczba rdzeni online, niezależnie od tego, czy hiperwątkowanie jest włączone, czy wyłączone.

$ ls -d /sys/devices/system/cpu/cpu* | wc -l
8

Kolejny łatwy sposób.

Znalazłem w ten sposób:

echo $((`cat /sys/devices/system/cpu/present | sed 's/0-//'` + 1))

Chcę tylko dodać trochę informacji do odpowiedzi @htaccess.

W CentOS 6.x dmidecode nie wyświetla informacji o liczbie rdzeni / wątków i faktycznie traktuje „CPU” jako „CPU” lub „Core” w lscpu, a nie „socket”.

Rodzina procesorów nie ma tu znaczenia.

• Procesor (y) = gniazda fizyczne
• Rdzeń na gniazdo - jak mówi
• więc całkowita liczba rdzeni = procesor (y) * Rdzeń na gniazdo

W twoim przypadku masz w sumie 4 pełne rdzenie.

Co również może być ważne, to „Wątki na rdzeń”. Ale masz 1, więc nie w twoim przypadku.

Prostym sposobem ustalenia liczby procesorów jest wydanie poniższych poleceń:

cat /proc/interrupts | egrep -i 'cpu'