Як отримати кількість ЦП / ядер в Linux з командного рядка?

У мене є цей сценарій, але я не знаю, як отримати останній елемент у роздруківці:

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

Останнім елементом має бути кількість процесорів, мінус 1.

grep -c ^processor /proc/cpuinfo     

буде рахувати кількість рядків, починаючи з "процесора" в /proc/cpuinfo

Для систем з гіпер-різьбленням можна використовувати

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

який повинен повернутися (наприклад) 8(тоді як команда вище повернеться 16)

Обробка вмісту /proc/cpuinfoє непотрібною бароко. Використовуйте nproc, який є частиною coreutils, тому він повинен бути доступний у більшості встановлень Linux.

Команда nprocдрукує кількість доступних для поточного процесу процесорних одиниць, яка може бути меншою, ніж кількість онлайн-процесорів.

Щоб знайти кількість усіх встановлених ядер / процесорів, використовуйте nproc --all

На моїй 8-ядерній машині:

$ nproc --all
8

Найбільш портативне рішення, яке я знайшов - це getconfкоманда:

getconf _NPROCESSORS_ONLN

Це працює як на Linux, так і на Mac OS X. Ще однією перевагою цього в порівнянні з деякими іншими підходами є те, що getconf існує вже давно. Деякі з старих машин Linux, якими я маю займатися, не мають доступних команд nprocабо lscpuкоманд, але вони є getconf.

^{Примітка редактора: В той час як утиліта є POSIX мандата , конкретні і значення не є. Однак, як зазначалося, вони працюють як на платформах Linux, так і на macOS; у FreeBSD / PC-BSD потрібно пропустити провідну .getconf _NPROCESSORS_ONLN_NPROCESSORS_CONF _}

Передмова:

• Проблема з /proc/cpuinfo-На відповідей є те , що вони синтаксична аналіз інформації , яка була призначена для людського споживання і , отже , не має формату , призначений для стабільної машини розбору : вихідний формат може відрізнятися на різних платформи і умовах середовища виконання; використання lscpu -pLinux (і sysctlmacOS) обходить цю проблему .

• getconf _NPROCESSORS_ONLN/ getconf NPROCESSORS_ONLNне розрізняє логічні та фізичні процесори.

Ось shфрагмент (сумісний з POSIX), який працює на Linux та macOS для визначення кількості онлайн- логічних або фізичних процесорів ; див. коментарі для деталей.

Використовується як lscpuдля Linux, так і sysctlдля macOS.

Примітка термінології : ЦП відноситься до найменшого процесорного блоку, як це бачиться в ОС. Кожні ядра, що не мають гіпер-різьблення, відповідають 1 процесору, тоді як ядра з гіпер-різьбленням містять більше 1 (зазвичай: 2) - логічного - процесора.
Linux використовує таку таксономію ^[1] , починаючи з найменшої одиниці:
CPU < core < socket < book < вузол
з кожним рівнем, що включає 1 або більше екземплярів наступного нижнього рівня.

#!/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] документація на macOSsysctl (3)

Зауважте, що похідні від BSD системи, крім macOS - наприклад, FreeBSD - підтримують лише той hw.ncpuключ sysctl, який застарілий у macOS; Я НЕ ясно , на який з нових ключів hw.npuвідповідає: hw.(logical|physical)cpu_[max].

^{Порада капелюха до @teambob, щоб допомогти виправити команду фізичного рахунку CPU lscpu.}

Caveat : lscpu -pвисновок НЕ включає стовпчик "книга" (на manсторінці згадуються "книги" як сутність між сокетом і вузлом в таксономічній ієрархії). Якщо «книга» знаходяться в грі на дану систему Linux ( хто - небудь знає , коли і як? ), Команда фізико-CPU-лічильник може під -report (це засноване на припущенні , що lscpuзвіти ідентифікатори , які не є чимось унікальним по більш -рівневі об'єкти ; наприклад: 2 різних ядра з 2-х різних гнізд можуть мати однаковий ідентифікатор).

Якщо ви збережете код вище як, скажімо, скрипт оболонкиcpus , зробите його виконуваним chmod +x cpusі помістите його в папку у вашому $PATH, ви побачите такий вихід:

$ cpus
logical  4
physical 4

^{[1] Xaekai проливає світло на те, що таке книга : " книга - це модуль, на якому розміщена плата з роз'ємами процесора, RAM-роз'ємами, IO-з'єднаннями по краю і гаком для інтеграції системи охолодження. Вони використовуються в мейнфреймах IBM . Детальна інформація: http://ewh.ieee.org/soc/cpmt/presentations/cpmt0810a.pdf "}

lscpu збирає форму інформації / архітектури процесора / proc / cpuinfon у форматі, який читає людина:

# 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

Дивіться також /unix/468766/understanding-output-of-lscpu .

Це працювало для мене. tail -nXдозволяє захоплювати лише останні X рядки.

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

Якщо у вас гіперточення, це повинно працювати на захоплення кількості фізичних ядер.

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

Для загальної кількості фізичних ядер:

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

На машинах з декількома розетками (або завжди) помножте вищенаведений результат на кількість розеток:

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

@ mklement0 має приємну відповідь нижче за допомогою lscpu. У коментарях я написав більш стисну версію

Ви також можете використовувати Python! Щоб отримати кількість фізичних ядер:

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

Щоб отримати кількість гіперточених ядер:

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

Рішення для кросплатформних платформ для Linux, MacOS, Windows:

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

Ось як я використовую для підрахунку кількості фізичних ядер, які є в Інтернеті в Linux:

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

або коротше:

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

Приклад (1 розетка):

> 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

Приклад (2 розетки):

> 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

Приклад (4 розетки):

> 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

Використання getconf - це справді самий портативний спосіб, однак змінна має різні назви в BSD та Linux для getconf, тому вам доведеться перевірити обидва, як це говорить: https://gist.github.com/jj1bdx/5746298 (також включає виправлення Solaris за допомогою ksh)

Я особисто використовую:

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

І якщо ви хочете цього в python, ви можете просто використовувати syscall getconf, використовуючи імпорт ОС модуля:

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

Що стосується nproc, вона є частиною GNU Coreutils, тому не доступна в BSD за замовчуванням. Він використовує sysconf (), а також після деяких інших методів.

Якщо ви хочете зробити це, щоб це працювало на Linux та OS X, ви можете зробити:

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

Це дуже просто. Просто використовуйте цю команду:

lscpu

Ви можете скористатися одним із наведених нижче способів для визначення кількості фізичних ядер ЦП.

• Порахуйте кількість унікальних ідентифікаторів ядра (приблизно еквівалентно grep -P '^core id\t' /proc/cpuinfo | sort -u | wc -l).

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

• Помножте кількість "ядер на сокет" на кількість розеток.

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

• Підраховуйте кількість унікальних логічних процесорів, якими користується ядро ​​Linux. Цей -pпараметр генерує вихід для легкого розбору та сумісний з більш ранніми версіями lscpu.

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

Просто для того, щоб повторити те, що сказали інші, існує ряд пов’язаних властивостей.

Щоб визначити кількість доступних процесорів:

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

Визначити кількість доступних технологічних одиниць (необов'язково таких самих, як кількість ядер). Це усвідомлює гіпертодування.

nproc

Я не хочу надто далеко ходити в кролячій норі, але ви також можете визначити кількість налаштованих процесорів (на відміну від просто доступних / онлайн-процесорів) через getconf _NPROCESSORS_CONF. Щоб визначити загальну кількість процесорів (офлайн та онлайн), ви хочете проаналізувати вихід lscpu -ap.

Я також думав, cat /proc/cpuinfoщо дасть мені правильну відповідь, проте нещодавно я побачив, що моя чотириядерна система Cortex A53 ARM показала лише одне ядро. Здається, що / proc / cpuinfo показує лише активні ядра, тоді як:

cat /sys/devices/system/cpu/present

є кращим показником того, що там є. Ви також можете

cat /sys/devices/system/cpu/online

щоб побачити, які сердечники є в Інтернеті, і

cat /sys/devices/system/cpu/offline

щоб побачити, які ядра офлайн. В online, offlineі presentsysfs запис повертає індекс процесорів, тому що повертається значення 0просто означає , що сердечник 0, в той час як значення, що повертається 1-3засіб ядер 1,2, і 3.

Дивіться https://www.kernel.org/doc/Documentation/ABI/testing/sysfs-devices-system-cpu

Далі слід дати вам кількість "справжніх" ядер як в гіперточеній, так і негіперпоточній системі. Принаймні, це спрацювало у всіх моїх тестах.

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

Не моя веб-сторінка, але ця команда від http://www.ixbrian.com/blog/?p=64&cm_mc_uid=89402252817914508279022&cm_mc_sid_50200000=1450827902 добре працює для мене на центсі. Він відображатиметься фактичним процесором навіть тоді, коли включена гіперточка.

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

Підраховуйте "core id" за методом "фізичний ідентифікатор", використовуючи awk зі зворотним відрахуванням на "процесор", якщо "core id" недоступний (наприклад, малиновий)

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)

cat /proc/cpuinfo | grep processor

Це спрацювало чудово. Коли я спробував першу відповідь, я отримав 3 процесора як вихід. Я знаю, що у мене є 4 процесори в системі, тому я просто зробив grepдля процесора, а вихід виглядав так:

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

 dmidecode  | grep -i cpu | grep Version

дає мені

Версія: процесор Intel (R) Xeon (R) E5-2667 v4 при 3,20 ГГц

Версія: процесор Intel (R) Xeon (R) E5-2667 v4 при 3,20 ГГц

Що є правильним підрахунком сокета - пошук вгору E5-2667підказує мені, що кожен сокет має 8 cores, тому множте і закінчуйте 16 coresпоперек 2 sockets.

Куди lscpuмені дають 20 CPUs- що абсолютно невірно - не знаю чому. (те саме стосується cat /proc/cpu- закінчується с 20.

Швидше, без виделки

Це робота з almsost всіх оболонки.

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

Для того, щоб залишатися сумісними з оболонки, тире, busboxта інших, які я використовував ncore=$((ncore+1))замість ((ncore++)).

баш версія

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

Якщо нормально, що ви можете використовувати Python, numexprмодуль має для цього функцію:

In [5]: import numexpr as ne

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

також це:

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

Для запиту цієї інформації з командного рядка використовуйте:

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

Або просто можна отримати цю інформацію з multiprocessing.cpu_count()функції

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

Або ще простіше використовувати os.cpu_count()

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

Якщо ви просто хочете порахувати фізичні ядра, ця команда зробила це для мене.

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

Досить базовий, але, здається, підраховує фактичні фізичні ядра, ігноруючи логічний підрахунок

Python 3 також пропонує декілька простих способів отримати його:

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

4

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

4

Використовуйте нижче запит, щоб отримати основні деталі

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

Підсумок: щоб отримати фізичні процесори, виконайте це:

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

щоб фізичні та логічні процесори зробили це:

grep -c ^processor /proc/cpuinfo

/proc << це золоте джерело будь-якої необхідної інформації про процеси та

/proc/cpuinfo << є золотим джерелом будь-якої інформації про процесор.