Как получить количество процессоров / ядер в Linux из командной строки?

У меня есть этот скрипт, но я не знаю, как получить последний элемент в распечатке:

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

последним элементом должно быть Число процессоров, минус 1.

22 ответов


cat /proc/cpuinfo | awk '/^processor/{print }' | wc -l

или просто

grep -c ^processor /proc/cpuinfo     

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

для систем с hyper-threading вы можете использовать

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

который должен вернуться (например) 8 (в то время как команда выше будет возвращать 16)


обработка содержание /proc/cpuinfo без нужды барокко. Использовать nproc который является частью coreutils, поэтому он должен быть доступен на большинстве установок Linux.

команда nproc печатает количество процессоров, доступных для текущего процесса, которое может быть меньше, чем количество сетевых процессоров.

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

на моем 8-ядерном компьютере:

$ nproc --all
8

самое портативное решение, которое я нашел, это :

getconf _NPROCESSORS_ONLN

это работает как на Linux, так и на Mac OS X. Еще одним преимуществом этого по сравнению с некоторыми другими подходами является то, что getconf существует уже давно. Некоторые из старых машин Linux, на которых я должен заниматься разработкой, не имеют nproc или lscpu доступные команды, но у них есть getconf.

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


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

  • на .

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


это работает для меня. tail -nX позволяет захватить только последние X строк.

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

Если у вас есть hyperthreading, это должно работать для захвата числа физическая ядер.

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

lscpu собирает информацию об архитектуре процессора form /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

для общего количества физических ядер:

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

на многосекционных машинах (или всегда) умножьте вышеуказанный результат на количество сокетов:

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

@mklement0 имеет довольно хороший ответ ниже, используя lscpu. Я написал более краткую версию в комментариях


использование 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, MacOS, Windows:

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

Если вы хотите сделать это, чтобы он работал на linux и OS X, вы можете сделать:

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

вы также можете использовать Python! Чтобы получить количество физических ядер:

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

получить количество ядер hyperthreaded:

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

следующее должно дать вам количество "реальных" ядер как в гиперпоточной, так и в не-гиперпоточной системе. По крайней мере, это сработало во всех моих тестах.

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

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

  • подсчитайте количество уникальных идентификаторов ядра (примерно эквивалентно 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. The -p опция генерирует вывод для легкого синтаксического анализа и совместима с более ранними версиями lscpu.

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


просто чтобы повторить то, что другие сказали, есть ряд связанных свойств.

чтобы определить количество доступных процессоров:

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

чтобы определить количество доступных процессоров (не обязательно такое же, как количество ядер). Это гиперпоточность-в курсе.

nproc

Я не хочу заходить слишком далеко в кроличью нору, но вы также можете определить количество настроенных процессоров (в отличие от просто доступных/онлайн-процессоров) через getconf _NPROCESSORS_CONF. Чтобы определить общее количество процессоров (автономных и онлайн), вы хотите проанализировать вывод lscpu -ap.


Count "core id " на метод" physical id "с использованием awk с резервным" процессором", если "core id" недоступен (например, raspberry)

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

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

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

или короче:

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

cat /proc/cpuinfo | grep processor

это сработало отлично. Когда я попробовал первый ответ, я получил 3 процессора в качестве вывода. Я знаю, что у меня есть 4 процессора в системе, поэтому я просто сделал grep для процессора и вывода выглядело так:

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

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

это работа с almsost all shell.

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

для того, чтобы оставаться совместимым с shell, тире, 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

этого команды:

echo $(nproc)

должен возвращать количество или ядра, доступные для системы


Не моя веб-страница, но эта команда из 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


 dmidecode  | grep -i cpu | grep Version

дает мне

версия: Intel(R) Xeon (R) CPU E5-2667 v4 @ 3.20 GHz

версия: Intel(R) Xeon (R) CPU E5-2667 v4 @ 3.20 GHz

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

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


Python 3 также предоставляет несколько простых способов получить его:

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

4

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

4