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

问题描述 投票：453回答：25

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

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

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

linux bash cpu
25个回答
566
投票
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）

7
投票

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

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

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

CORES=$(grep -c ^processor /proc/cpuinfo 2>/dev/null || sysctl -n hw.ncpu)
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
  • 将每个插槽的核心数乘以插槽数。 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总数（离线和在线）。

3
投票

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

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

或简而言之：

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

我还认为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和present sysfs条目返回CPUS的索引，因此0的返回值仅表示核心0，而1-3的返回值表示核心1,2和3。

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

2
投票

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

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

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

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

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)
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
1
投票

更快，没有叉子

这项工作与几乎所有qazxsw poi。

shell

为了与ncore=0 while read line ;do [ "$line" ] && [ -z "${line%processor*}" ] && ncore=$((ncore+1)) done </proc/cpuinfo echo $ncore 4 ，shell，dash和其他人保持兼容，我使用了busybox而不是ncore=$((ncore+1))。

((ncore++)) version

bash
570
投票

处理/proc/cpuinfo的内容是不必要的巴洛克式。使用nproc是coreutils的一部分，因此它应该可以在大多数Linux安装中使用。

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

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

在我的8核机器上：

$ nproc --all
8
1
投票

如果你可以使用Python，那么ncore=0 while read -a line ;do [ "$line" = "processor" ] && ((ncore++)) done </proc/cpuinfo echo $ncore 4 模块有一个功能：

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()
1
投票

如果你只想计算物理核心，这个命令就是为我做的。

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

非常基本，但似乎计算实际的物理内核，忽略逻辑计数

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

给我

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

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

哪个是正确的套接字计数 - 查找 dmidecode | grep -i cpu | grep Version 告诉我每个套接字都有E5-2667，所以乘以8 cores的16 cores。

哪里2 sockets给我lscpu - 这是完全错误的 - 不知道为什么。 （同样适用于20 CPUs - 以cat /proc/cpu结束。

0
投票

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

20

4

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

4

0
投票

使用以下查询获取核心详细信息

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

简介：获取物理CPU执行此操作：

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

获取物理和逻辑CPU执行此操作：

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

grep -c ^processor /proc/cpuinfo <<这是您需要有关流程和信息的任何信息的黄金来源

/proc <<是任何CPU信息的黄金来源。

235
投票

我找到的最便携的解决方案是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上，你必须省略领先的_。

82
投票

前言：

  • 基于/proc/cpuinfo的答案的问题在于它们解析了供人类消费的信息，因此缺乏为机器解析设计的稳定格式：输出格式可能因平台和运行时条件而异;在Linux上使用lscpu -p（以及macOS上的sysctl）绕过了这个问题。
  • getconf _NPROCESSORS_ONLN / getconf NPROCESSORS_ONLN不区分逻辑CPU和物理CPU。

这是一个sh（POSIX兼容）片段，适用于Linux和macOS，用于确定 - 在线 - 逻辑或物理CPU的数量;请参阅评论了解详情。

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

术语说明：CPU是指操作系统看到的最小处理单元。非超线程内核每个对应1个CPU，而超线程内核包含多于1个（通常为2个）逻辑CPU。 Linux使用以下分类法，从最小单位开始：CPU <core <socket <book <node，每个级别包含下一个较低级别的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] macOS sysctl (3) documentation

请注意，除macOS之外的BSD派生系统（例如FreeBSD）仅支持hw.ncpu的sysctl密钥，这在macOS上已弃用;我不清楚hw.npu对应的新密钥：hw.(logical|physical)cpu_[max]。

向@teambob提供帮助纠正物理CPU计数lscpu命令的提示。

警告：lscpu -p输出不包括“book”列（man页面提到“books”作为分类层次结构中socket和node之间的实体）。如果给定的Linux系统上有“书籍”（有人知道何时以及如何？），则物理CPU计数命令可能报告不足（这是基于lscpu报告非唯一ID的假设）更高级别的实体;例如：来自2个不同套接字的2个不同核心可以具有相同的ID）。

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

$ cpus
logical  4
physical 4
33
投票

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。

13
投票

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

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

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

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

对于物理核心的总数：

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

在多插槽机器上（或总是），将上面的结果乘以套接字的数量：

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

使用lscpu，@ mklement0下面有一个很好的答案。我在评论中写了一个更简洁的版本

8
投票

你也可以使用Python！要获取物理核心数：

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

要获得超线程核心的数量：

$ python -c "import psutil; print(psutil.cpu_count(logical=True))"
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（）以及其他一些方法。

最新问题
© www.soinside.com 2019 - 2024. All rights reserved.