Как получить количество процессоров / ядер в 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-машинах, на которых мне приходится заниматься разработкой, нет доступных команд nprocor lscpu, но они есть getconf.

^{Примечание редактора: в то время как getconf утилита является обязательной для POSIX , специфика _NPROCESSORS_ONLNи _NPROCESSORS_CONF значения - нет. Тем не менее, как уже говорилось, они работают на платформах Linux, а также на MacOS; во FreeBSD / PC-BSD вы должны опустить ведущие _.}

Предисловие:

• Проблема с /proc/cpuinfo-На ответов является то , что они синтаксическая анализ информации , которая была предназначена для человеческого потребления и , следовательно , не имеет формата , предназначенный для стабильной машины разбора : выходной формат может отличаться на разных платформы и условиях среды выполнения; использование lscpu -pв Linux (и sysctlв macOS) позволяет обойти эту проблему .

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

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

Использует lscpuдля Linux, иsysctl для macOS.

Примечание по терминологии : ЦП относится к наименьшей единице обработки, видимой ОС. Ядра без гиперпоточности соответствуют одному ЦП, тогда как ядра с многопоточностью содержат более 1 (обычно 2) - логического - ЦП.
Linux использует следующую таксономию ^[1] , начиная с самого маленького блока:
CPU < ядро < сокет < книга < узел
с каждым уровнем , содержащим 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.}

Предостережение : lscpu -pвывод НЕ включает столбец «книга» ( manстраница упоминает «книги» как объект между сокетом и узлом в таксономической иерархии). Если «книги» находятся в игре в данной системе Linux ( кто-нибудь знает, когда и как? ), Команда физического-CPU-count может быть ниже -report (это основано на предположении, что lscpuидентификаторы отчетов не являются уникальными для более высоких -уровневые объекты , например: 2 разных ядра из 2 разных сокетов могут иметь одинаковый идентификатор).

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

$ cpus
logical  4
physical 4

^{[1] Xaekai проливает свет на то, что такое книга : « книга - это модуль, в котором размещена печатная плата с гнездами ЦП, ОЗУ, соединениями ввода-вывода по краю и крюком для интеграции системы охлаждения. Они используются в мэйнфреймах 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, импортировав модуль os:

$ 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что даст мне правильный ответ, однако недавно я увидел, что моя четырехъядерная система ARM Cortex A53 показала только одно ядро. Кажется, что / 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 прекрасно работает для меня в centos. Он будет отображать фактический процессор даже при включенной гиперпоточности.

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

Подсчитайте «идентификатор ядра» для каждого метода «физического идентификатора», используя awk с отступом на счетчике «процессора», если «идентификатор ядра» недоступны (например, raspberry)

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) CPU E5-2667 v4 @ 3.20 ГГц

Версия: Intel (R) Xeon (R) CPU E5-2667 v4 @ 3.20 ГГц

Что является правильным количеством сокетов - поиск E5-2667говорит мне, что каждый сокет имеет 8 cores, так что умножьте и в конечном итоге с 16 coresпоперечным 2 sockets.

Где lscpuдать мне 20 CPUs- что совершенно неправильно - не знаю почему. (то же самое касается cat /proc/cpu- заканчивается 20.

Быстрее без вилки

Это работа с милостыней всех ракушка,

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

Чтобы оставаться совместимым с ракушка, тире, BusyBoxи другие, я использовал 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 << является золотым источником любой информации о процессоре.