如何从命令行获取Linux中的CPU /核心数？

时间：2011-06-25 22:52:34

标签： linux bash cpu

我有这个脚本，但我不知道如何获取打印输出中的最后一个元素：

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

最后一个元素应该是CPU数量减1。

29 个答案:

答案 0 :(得分：556)

处理/proc/cpuinfo的内容是不必要的巴洛克式。使用属于coreutils的nproc，因此它应该适用于大多数Linux安装。

命令nproc打印当前进程可用的处理单元数，可能少于在线处理器数。

要查找所有已安装核心/处理器的数量，请使用nproc --all

在我的8核机器上：

$ nproc --all
8

答案 1 :(得分：539)

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

或只是

grep -c ^processor /proc/cpuinfo

将计算/proc/cpuinfo

中以“processor”开头的行数

对于具有超线程的系统，您可以使用

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

应该返回（例如）8（而上面的命令将返回16）

答案 2 :(得分：225)

我找到的最便携的解决方案是getconf命令：

getconf _NPROCESSORS_ONLN

这适用于Linux和Mac OS X.这比其他一些方法的另一个好处是getconf已经存在了很长时间。我必须进行开发的一些较旧的Linux机器没有可用的nproc或lscpu命令，但它们有getconf。

编者注：虽然the getconf utility is POSIX-mandated，但具体的_NPROCESSORS_ONLN和_NPROCESSORS_CONF 值却不是。 也就是说，如上所述，它们可以在Linux平台和macOS上运行;在FreeBSD / PC-BSD上，你必须省略前导_。

答案 3 :(得分：78)

前言：

  • 基于/proc/cpuinfo的答案的问题是他们解析了用于人消费的信息，因此缺乏为机器解析而设计的稳定格式：输出格式可能因平台和运行时条件而异; 在Linux上使用lscpu -p（以及在macOS上使用sysctl）绕过该问题。

  • getconf _NPROCESSORS_ONLN / getconf NPROCESSORS_ONLN并不区分逻辑和物理 CPU。

此处＆＃39; sa sh（符合POSIX标准）摘录适用于 Linux和macOS ，用于确定 - online - 逻辑或物理 CPU ;有关详细信息，请参阅评论。

对Linux使用lscpu，对macOS使用sysctl。

术语说明： CPU 是指操作系统看到的最小处理单元。非超线程内核每个对应1个CPU，而超线程内核包含1个以上（通常为2个）逻辑CPU。 Linux使用以下分类法，从最小的单位开始： CPU ＆lt; 核心＆lt; socket ＆lt; book ＆lt; node ，每个级别包含下一个较低级别的1个或多个实例 我的知识在这里有些不稳定 - 如果我错了，请告诉我。 有谁知道＆＃34;书＆＃34;在这种情况下？

#!/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] macOS sysctl (3) documentation

请注意，除macOS之外的BSD派生系统（例如FreeBSD）仅支持hw.ncpu的{​​{1}}密钥，这些密钥在macOS上已弃用;我不清楚哪个新密钥sysctl对应于：hw.npu。

向@teambob提供帮助纠正物理CPU计数hw.(logical|physical)cpu_[max]命令的提示。

警告：lscpu输出不包含＆＃34;书＆＃34;列（lscpu -p页面提及＆＃34;书籍＆＃34;作为分类层次结构中套接字和节点之间的实体）。如果＆＃34;书籍＆＃34;在给定的Linux系统上运行（有谁知道何时以及如何？），物理CPU计数命令可能在 - 报告下（这是基于假设） man报告跨越更高级别实体的非唯一的ID ;例如：来自2个不同套接字的2个不同核心可能具有相同的ID。）

如果您将上面的代码保存为shell脚本lscpu，请使用cpus使其可执行，并将其放在chmod +x cpus的文件夹中，您将看到输出如下：

$PATH

答案 4 :(得分：29)

lscpu以人类可读格式收集CPU架构信息表/ 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

另见https://unix.stackexchange.com/questions/468766/understanding-output-of-lscpu。

答案 5 :(得分：13)

这对我有用。 tail -nX允许您只抓取最后X行。

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

如果您有超线程，那么这应该可以用于获取物理核心的数量。

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

答案 6 :(得分：8)

对于物理核心的总数：

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在下面有一个很好的答案。我在评论中写了一个更简洁的版本

答案 7 :(得分：7)

适用于Linux，MacOS，Windows的跨平台解决方案：

{{1}}

答案 8 :(得分：7)

使用getconf确实是最便携的方式，但是变量在BSD和Linux中有不同的名称来getconf，所以你必须测试两者，因为这个要点建议： https://gist.github.com/jj1bdx/5746298 （还包括使用ksh的Solaris修复程序）

我个人使用：

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

如果你想在python中使用它，你可以通过导入os模块来使用syscall getconf使用：

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

至于nproc，它是GNU Coreutils的一部分，默认情况下在BSD中不可用。它使用sysconf（）以及其他一些方法。

答案 9 :(得分：7)

您也可以使用Python！获取物理核心数量：

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

获取超线程核心的数量：

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

答案 10 :(得分：6)

如果你想这样做，它适用于linux和OS X，你可以这样做：

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

答案 11 :(得分：3)

您可以使用以下方法之一来确定物理 CPU核心的数量。

  • 计算唯一核心ID的数量（大致相当于grep -P '^core id\t' /proc/cpuinfo | sort -u | wc -l）。

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

  • 将每个插槽的核心数乘以＆＃39;按插座的数量。

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

  • 计算Linux内核使用的唯一逻辑CPU的数量。 -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输出的CPU的总数（离线和在线）。

答案 12 :(得分：3)

以下内容应该为您提供＆＃34;真实＆＃34;超线程和非超线程系统上的核心。至少它在我的所有测试中都有效。 

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

答案 13 :(得分：2)

这就是我用来计算Linux上在线物理核心数量的方式：

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

或简称：

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

答案 14 :(得分：2)

我还认为computed: { userInput: { get: funciton(){ return this.$store.state.userInput }, set: function(newVal){ this.$store.commit('updateUserInput', newVal) } } 将为我提供正确的答案，但是最近我看到我的ARM四核Cortex A53系统仅显示一个核。似乎/ proc / cpuinfo仅显示活动的内核，而：

cat /proc/cpuinfo

是对其中内容的更好衡量。您也可以

cat /sys/devices/system/cpu/present

查看哪些内核处于在线状态，

cat /sys/devices/system/cpu/online

查看哪些核心处于脱机状态。 cat /sys/devices/system/cpu/offline，online和offline sysfs条目返回CPUS的索引，因此返回值present仅表示核心0，而返回值{{ 1}}表示核心1,2和3。

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

答案 15 :(得分：1)

如果“核心ID”不可用（如覆盆子），使用awk并使用“处理器”计数后退计算每个“物理ID”方法计算“核心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)

答案 16 :(得分：1)

cat /proc/cpuinfo | grep processor

这很好用。当我尝试第一个答案时，我得到3个CPU作为输出。我知道系统上有4个CPU，所以我只为处理器做了一个grep，输出看起来像这样：

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

答案 17 :(得分：1)

更快，没有叉子

这项工作与almsost所有。

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

为了与，，及其他人保持兼容，我使用ncore=$((ncore+1))代替((ncore++))。

版本

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

答案 18 :(得分：1)

如果您可以使用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())"

答案 19 :(得分：1)

如果您只想计算物理核，则此命令对我有用。

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

相当基本，但似乎要计算实际的物理核心，而忽略逻辑计数

答案 20 :(得分：0)

如果有人想知道，以下是 Python psutil.cpu_count(logical=False) 调用在 Linux 上的等效 shell 脚本中执行的操作：

cat /sys/devices/system/cpu/cpu[0-9]*/topology/core_cpus_list | uniq | wc -l

这里有一个稍长的版本，如果 core_cpus_list 不可用（psutil 有这种回退），则回退到已弃用的 thread_siblings_list 文件中的信息：

cat /sys/devices/system/cpu/cpu[0-9]*/topology/{core_cpus_list,thread_siblings_list} | sort -u | wc -l

答案 21 :(得分：0)

以上答案适用于大多数情况，但是如果您处于docker容器环境中，并且您的容器受CpusetCpus限制，那么您实际上无法通过上述方法获得真正的cpu核心方法。

在这种情况下，您需要执行以下操作以获得真正的cpu内核：

cat /proc/stat | grep cpu | grep -E 'cpu[0-9]+' | wc -l

答案 22 :(得分：0)

Fravadona's answer is awesome and correct，但它需要lscpu的存在。由于在需要大量物理核心的系统上不存在该核心，因此我尝试提出一种仅依赖proc/cpuinfo

的核心

cat /proc/cpuinfo | grep -B2 'core id' | sed 's/siblings.*/'/ | tr -d '[:space:]' | sed 's/--/\n/'g | sort -u | wc -l

它工作得很好，但是不幸的是它不如Fravadona那样强大，因为如果它会破裂

  • /proc/cpuinfo中字段的名称或顺序更改
  • grep将其插入的行分隔符（当前为--）替换为其他字符串。

但是，除此之外，它还可以完美运行：）

这里是正在发生的一切的快速解释

grep -B2 'core id'

仅获取我们感兴趣的行（即“核心ID”和前2行）

sed 's/siblings.*/'/

删除“兄弟姐妹...”行

tr -d '[:space:]'

替换空格字符

sed 's/--/\n/'g

通过换行符替换grep插入的'-'字符

sort -u

按“物理ID，核心ID”分组

wc -l

计算行数

总的来说，这让我很高兴。我从没想过我可以将所需的行连接在一起，以按“物理ID”和“核心ID”分组。这有点hacky，但是行得通。

如果任何一位大师知道简化这种混乱的方法，请告诉我。

答案 23 :(得分：0)

这很简单。只需使用以下命令：

lscpu

答案 24 :(得分：0)

摘要： 要获取物理CPU ，请执行以下操作：

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

要获取物理和逻辑 CPU，请执行以下操作：

grep -c ^processor /proc/cpuinfo

/proc <<，这是您需要的有关流程和

的所有信息的黄金来源

/proc/cpuinfo <<是所有CPU信息的黄金来源。

答案 25 :(得分：0)

在下面的查询中使用以获取核心详细信息

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

答案 26 :(得分：0)

Python 3还提供了一些简单的方法来获取它：

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

4 

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

4

答案 27 :(得分：0)

 dmidecode  | grep -i cpu | grep Version

给了我

  

版本：Intel（R）Xeon（R）CPU E5-2667 v4 @ 3.20GHz

     

版本：Intel（R）Xeon（R）CPU E5-2667 v4 @ 3.20GHz

套接字计数是正确的 - 查找E5-2667告诉我每个套接字都有8 cores，因此在16 cores之间相乘，最后得2 sockets。

lscpu给我20 CPUs的地方 - 这是完全错误的 - 不确定原因。 （同样适用于cat /proc/cpu - 以20结束。

答案 28 :(得分：0)

不是我的网页，但来自http://www.ixbrian.com/blog/?p=64&cm_mc_uid=89402252817914508279022&cm_mc_sid_50200000=1450827902的这个命令对我来说很有用。即使启用了超线程，它也会显示实际的cpus。

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

相关问题
最新问题