Bagaimana cara mendapatkan jumlah CPU / core di Linux dari baris perintah?

Saya memiliki skrip ini, tetapi saya tidak tahu cara mendapatkan elemen terakhir dalam hasil cetak:

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

Elemen terakhir adalah jumlah CPU, minus 1.

grep -c ^processor /proc/cpuinfo     

akan menghitung jumlah baris yang dimulai dengan "prosesor" di /proc/cpuinfo

Untuk sistem dengan hyper-threading, Anda bisa menggunakannya

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

yang harus kembali (misalnya) 8(sedangkan perintah di atas akan kembali 16)

Memproses isi /proc/cpuinfobarok tidak perlu. Gunakan nproc yang merupakan bagian dari coreutils, jadi itu harus tersedia pada kebanyakan instalasi Linux.

Command nprocmencetak jumlah unit pemrosesan yang tersedia untuk proses saat ini, yang mungkin kurang dari jumlah prosesor online.

Untuk menemukan jumlah semua inti / prosesor yang digunakan, gunakan nproc --all

Di mesin 8-core saya:

$ nproc --all
8

Solusi paling portabel yang saya temukan adalah getconfperintah:

getconf _NPROCESSORS_ONLN

Ini berfungsi pada Linux dan Mac OS X. Manfaat lain dari ini atas beberapa pendekatan lain adalah bahwa getconf telah ada sejak lama. Beberapa mesin Linux lama yang harus saya lakukan pengembangannya tidak memiliki nprocatau lscpuperintah yang tersedia, tetapi mereka punya getconf.

^{Catatan editor: Sementara itu getconf utilitas adalah POSIX-mandat , spesifik _NPROCESSORS_ONLNdan _NPROCESSORS_CONF nilai-nilai yang tidak. Yang mengatakan, seperti yang dinyatakan, mereka bekerja pada platform Linux dan juga pada macOS; pada FreeBSD / PC-BSD, Anda harus menghilangkan yang terdepan _.}

Kata pengantar:

• The masalah dengan /proc/cpuinfojawaban berbasis adalah bahwa mereka informasi mengurai yang dimaksudkan untuk manusia konsumsi dan dengan demikian tidak memiliki format yang stabil dirancang untuk mesin parsing : format output dapat berbeda di seluruh platform dan kondisi runtime; menggunakan lscpu -pdi Linux (dan sysctldi macOS) melewati masalah itu .

• getconf _NPROCESSORS_ONLNSaya getconf NPROCESSORS_ONLNtidak membedakan antara CPU logis dan fisik .

Berikut shcuplikan (POSIX-compliant) yang berfungsi di Linux dan macOS untuk menentukan jumlah - online - logis atau CPU fisik ; lihat komentar untuk detailnya.

Penggunaan lscpuuntuk Linux, dan sysctluntuk macOS.

Catatan terminologi : CPU mengacu pada unit pemrosesan terkecil seperti yang terlihat oleh OS. Core non-hyper-threading masing-masing sesuai dengan 1 CPU, sedangkan core hyper-threading mengandung lebih dari 1 (biasanya: 2) - logical - CPU.
Linux menggunakan taksonomi berikut ^[1] , dimulai dengan unit terkecil: simpul
CPU < core < socket < book < dengan masing-masing level terdiri dari 1 atau lebih instance dari level bawah berikutnya.

#!/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] dokumentasi macOSsysctl (3)

Perhatikan bahwa sistem yang diturunkan BSD selain macOS - misalnya, FreeBSD - hanya mendukung hw.ncpukunci untuk sysctl, yang tidak digunakan lagi pada macOS; Aku tidak jelas di mana kunci baru hw.npusesuai dengan: hw.(logical|physical)cpu_[max].

^{Ujung topi untuk @teambob untuk membantu memperbaiki perintah fisik-CPU-count lscpu.}

Peringatan : lscpu -poutput TIDAK menyertakan kolom "buku" ( manhalaman menyebutkan "buku" sebagai entitas antara soket dan simpul dalam hierarki taksonomi). Jika "buku" dalam bermain pada sistem Linux tertentu ( apakah ada yang tahu kapan dan bagaimana? ), Perintah fisik-CPU-hitung mungkin di bawah -Laporan (ini didasarkan pada asumsi bahwa lscpuID laporan yang non-unik di seluruh lebih tinggi entitas -level ; misalnya: 2 core yang berbeda dari 2 soket yang berbeda dapat memiliki ID yang sama).

Jika Anda menyimpan kode di atas sebagai, misalnya, skrip shellcpus , membuatnya dapat dieksekusi dengan chmod +x cpusdan meletakkannya di folder di Anda $PATH, Anda akan melihat output seperti berikut:

$ cpus
logical  4
physical 4

^{[1] Xaekai menjelaskan apa itu buku : " buku adalah modul yang menampung papan sirkuit dengan soket CPU, soket RAM, koneksi IO di sepanjang tepinya, dan pengait untuk integrasi sistem pendingin. Buku tersebut digunakan dalam mainframe IBM Info lebih lanjut: http://ewh.ieee.org/soc/cpmt/presentations/cpmt0810a.pdf "}

lscpu mengumpulkan formulir informasi arsitektur CPU / proc / cpuinfon dalam format yang dapat dibaca manusia:

# 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

Lihat juga /unix/468766/understanding-output-of-lscpu .

Ini berhasil untuk saya. tail -nXmemungkinkan Anda untuk hanya mengambil garis X terakhir.

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

Jika Anda mengalami hiphreading, ini seharusnya berfungsi untuk meraih jumlah inti fisik .

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

Untuk jumlah total inti fisik:

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

Pada mesin multi-socket (atau selalu), gandakan hasil di atas dengan jumlah soket:

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

@ mklement0 memiliki jawaban yang cukup bagus di bawah ini menggunakan lscpu. Saya telah menulis versi yang lebih ringkas dalam komentar

Anda juga dapat menggunakan Python! Untuk mendapatkan jumlah inti fisik:

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

Untuk mendapatkan jumlah core ber-hiphread:

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

Solusi lintas platform untuk Linux, MacOS, Windows:

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

Inilah cara yang saya gunakan untuk menghitung jumlah core fisik yang sedang online di Linux:

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

atau singkatnya:

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

Contoh (1 soket):

> 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

Contoh (2 soket):

> 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

Contoh (4 soket):

> 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

Menggunakan getconf memang cara yang paling portabel, namun variabel memiliki nama yang berbeda di BSD dan Linux untuk getconf, jadi Anda harus menguji keduanya, seperti yang disarankan intinya: https://gist.github.com/jj1bdx/5746298 (juga termasuk perbaikan Solaris menggunakan ksh)

Saya pribadi menggunakan:

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

Dan jika Anda menginginkan ini dengan python, Anda bisa menggunakan syscall getconf menggunakan dengan mengimpor modul os:

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

Adapun nproc, itu adalah bagian dari GNU Coreutils, jadi tidak tersedia di BSD secara default. Ia menggunakan sysconf () juga setelah beberapa metode lain.

Jika Anda ingin melakukan ini agar berfungsi di linux dan OS X, Anda dapat melakukannya:

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

Ini sangat sederhana. Cukup gunakan perintah ini:

lscpu

Anda dapat menggunakan salah satu metode berikut untuk menentukan jumlah inti CPU fisik .

• Hitung jumlah id inti unik (kira-kira setara dengan grep -P '^core id\t' /proc/cpuinfo | sort -u | wc -l).

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

• Lipat gandakan jumlah inti per soket dengan jumlah soket.

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

• Hitung jumlah CPU logis unik seperti yang digunakan oleh kernel Linux. The -ppilihan menghasilkan output untuk mudah parsing dan kompatibel dengan versi sebelumnya lscpu.

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

Hanya untuk mengulangi apa yang dikatakan orang lain, ada sejumlah properti terkait.

Untuk menentukan jumlah prosesor yang tersedia:

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

Untuk menentukan jumlah unit pemrosesan yang tersedia (belum tentu sama dengan jumlah core). Ini sadar hipertensi.

nproc

Saya tidak ingin terlalu jauh ke lubang kelinci, tetapi Anda juga dapat menentukan jumlah prosesor yang dikonfigurasi (sebagai lawan dari prosesor yang hanya tersedia / online) melalui getconf _NPROCESSORS_CONF. Untuk menentukan jumlah total CPU (offline dan online) Anda ingin menguraikan output lscpu -ap.

Saya juga berpikir cat /proc/cpuinfoakan memberi saya jawaban yang benar, namun saya baru-baru ini melihat bahwa sistem ARM quad core Cortex A53 saya hanya menunjukkan satu inti. Tampaknya / proc / cpuinfo hanya menampilkan core aktif, sedangkan:

cat /sys/devices/system/cpu/present

adalah ukuran yang lebih baik dari apa yang ada di sana. Anda juga bisa

cat /sys/devices/system/cpu/online

untuk melihat core mana yang online, dan

cat /sys/devices/system/cpu/offline

untuk melihat core mana yang offline. The online, offlinedan presentsysfs entri mengembalikan indeks dari CPU, sehingga nilai kembali dari 0hanya berarti inti 0, sedangkan nilai kembali dari 1-3sarana core 1,2, dan 3.

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

Yang berikut ini akan memberi Anda jumlah inti "nyata" pada sistem yang di-hyperhread dan non-hyperthread. Setidaknya itu berhasil di semua tes saya.

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

Bukan halaman web saya, tetapi perintah ini dari http://www.ixbrian.com/blog/?p=64&cm_mc_uid=89402252817914508279022&cm_mc_sid_50200000=1450827902 bekerja dengan baik untuk saya di centos. Ini akan menunjukkan CPU yang sebenarnya bahkan ketika hyperthreading diaktifkan.

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

Hitung "id inti" per metode "id fisik" menggunakan awk dengan mundur pada "prosesor" hitung jika "id inti" tidak tersedia (seperti 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

Ini bekerja dengan baik. Ketika saya mencoba jawaban pertama saya mendapatkan 3 CPU sebagai output. Saya tahu bahwa saya memiliki 4 CPU pada sistem jadi saya hanya melakukan grepuntuk prosesor dan hasilnya terlihat seperti ini:

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

 dmidecode  | grep -i cpu | grep Version

memberi saya

Versi: Intel (R) Xeon (R) CPU E5-2667 v4 @ 3.20GHz

Versi: Intel (R) Xeon (R) CPU E5-2667 v4 @ 3.20GHz

Yang mana jumlah soket yang benar - mencari E5-2667tahu saya memiliki masing-masing soket 8 cores, jadi gandakan dan berakhir dengan 16 coresdi seberang 2 sockets.

Di mana lscpumemberi saya 20 CPUs- yang sama sekali tidak benar - tidak yakin mengapa. (Hal yang sama berlaku untuk cat /proc/cpu- berakhir dengan 20.

Lebih cepat, tanpa garpu

Ini bekerja dengan hampir semua kulit.

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

Agar tetap kompatibel dengan kulit, berlari, busyboxdan yang lainnya, saya telah menggunakan ncore=$((ncore+1))sebagai gantinya ((ncore++)).

pesta Versi: kapan

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

Jika Anda bisa menggunakan Python, maka numexprmodul memiliki fungsi untuk ini:

In [5]: import numexpr as ne

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

juga ini:

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

Untuk menanyakan informasi ini dari prompt perintah, gunakan:

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

Atau sederhananya dimungkinkan untuk mendapatkan info ini dari multiprocessing.cpu_count()fungsi

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

Atau bahkan lebih mudah digunakan os.cpu_count()

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

Jika Anda hanya ingin menghitung inti fisik, perintah ini melakukannya untuk saya.

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

Cukup mendasar, tetapi tampaknya menghitung inti fisik aktual, mengabaikan perhitungan logis

Python 3 juga menyediakan beberapa cara sederhana untuk mendapatkannya:

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

4

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

4

Gunakan kueri di bawah ini untuk mendapatkan detail inti

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

Ringkasan: untuk mendapatkan CPU fisik lakukan ini:

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

untuk mendapatkan CPU fisik dan logis lakukan ini:

grep -c ^processor /proc/cpuinfo

/proc << ini adalah sumber emas dari setiap info yang Anda butuhkan tentang proses dan

/proc/cpuinfo << adalah sumber emas dari setiap informasi CPU.