Linux'ta CPU / çekirdek sayısını komut satırından nasıl elde edebilirim?

Bu komut dosyası var, ancak çıktıdaki son öğeyi nasıl alacağımı bilmiyorum:

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

Son öğe, eksi 1 olmak üzere CPU sayısı olmalıdır.

grep -c ^processor /proc/cpuinfo     

"işlemci" ile başlayan satır sayısını sayar /proc/cpuinfo

Hiper iş parçacıklı sistemler için şunları kullanabilirsiniz:

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

döndürülmelidir (örneğin) 8(yukarıdaki komut geri dönecektir 16)

İçeriğinin işlenmesi /proc/cpuinfogereksiz bir şekilde baroktur. Coreutils'in bir parçası olan nproc kullanın , bu nedenle çoğu Linux kurulumunda kullanılabilir olmalıdır.

Komut nproc, geçerli işlem için kullanılabilir olan ve çevrimiçi işlemci sayısından daha az olabilecek işlem birimi sayısını yazdırır.

Kurulu tüm çekirdek / işlemci sayısını bulmak için nproc --all

8 çekirdekli makinemde:

$ nproc --all
8

Bulduğum en taşınabilir çözüm getconfkomut:

getconf _NPROCESSORS_ONLN

Bu hem Linux hem de Mac OS X üzerinde çalışır. Diğer bazı yaklaşımlara göre bunun bir başka yararı da getconf'un uzun zamandır var olmasıdır. Geliştirme yapmak zorunda olduğum bazı eski Linux makinelerinde nprocveya lscpukomutları mevcut değil, ama var getconf.

^{Editörün notu: Yardımcı program POSIX tarafından zorunlu kılınmış olsa dagetconf , spesifik _NPROCESSORS_ONLNve _NPROCESSORS_CONF değerler değildir. Bununla birlikte, belirtildiği gibi, Linux platformlarında ve macOS'ta çalışıyorlar; FreeBSD / PC-BSD'de liderleri atlamanız gerekir _.}

Önsöz:

• Sorun /proc/cpuinfotabanlı cevapları için yapılmıştı kişilermişiz ayrıştırma bilgi olmasıdır insan böylece tüketim ve makine çözümlemesi için tasarlanmış istikrarlı biçimi bulunmadığı : çıkış biçimi platformları ve çalışma zamanı koşulları karşısında farklı olabilir; kullanarak lscpu -pLinux (ve üzerinde sysctlMacOS üzerine) bu sorunu atlar .

• getconf _NPROCESSORS_ONLN/ mantıksal ve fiziksel CPU'ları getconf NPROCESSORS_ONLNayırt etmez .

İşte - çevrimiçi - mantıksal veya fiziksel CPU sayısını belirlemek için Linux ve macOSsh üzerinde çalışan (POSIX uyumlu) bir snippet ; ayrıntılar için yorumlara bakın.

lscpuLinux için kullanır vesysctl macOS .

Terminoloji notu : CPU , işletim sistemi tarafından görülen en küçük işlem birimini ifade eder. Hiper iş parçacıklı olmayan çekirdeklerin her biri 1 CPU'ya karşılık gelirken, hiper iş parçacıklı çekirdekler 1'den fazla (tipik olarak: 2) - mantıksal - CPU içerir.
Linux, en küçük birimden başlayarak aşağıdaki sınıflandırmayı ^[1] kullanır :
CPU < çekirdek < soket < kitap < düğümü
, her düzey bir sonraki düşük düzeyden 1 veya daha fazla örneği içerir.

#!/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)belgeleri

MacOS dışındaki BSD'den türetilen sistemlerin (ör. FreeBSD) yalnızca macOS'ta kullanımdan kaldırılan hw.ncpuanahtarı desteklediğini unutmayın sysctl; Yeni anahtarlardan hangisine hw.npukarşılık geldiğinden emin değilim :hw.(logical|physical)cpu_[max] .

^{Fiziksel CPU sayımı lscpukomutunu düzeltmeye yardımcı olması için şapkanın @teambob adresine ipucu .}

Uyarı : lscpu -pçıktı bir "kitap" sütununu İÇERMEZ ( mansayfa, taksonomik hiyerarşideki soket ve düğüm arasında bir varlık olarak "kitaplardan bahseder"). "Kitaplar" belirli bir Linux sisteminde oynatılıyorsa ( kimse ne zaman ve nasıl olduğunu biliyor mu? ), Fiziksel-CPU-sayısı komutu raporlamanın altında olabilir (bu, daha yüksek bir alandalscpu benzersiz olmayan kimlikleri bildirdiği varsayımına dayanır) seviyeli varlıklar ; örneğin: 2 farklı soketten 2 farklı çekirdek aynı kimliğe sahip olabilir).

Eğer varsa yukarıdaki kabuk komut dosyası, demek gibi kod tasarrufucpus ile çalıştırılabilir hale chmod +x cpusve klasördeki yer bunu Gözlerinde farklı $PATH, aşağıdaki gibi çıktı göreceksiniz:

$ cpus
logical  4
physical 4

^{[1] Xaekai bir kitabın ne olduğuna ışık tutuyor : " kitap , CPU soketleri, RAM soketleri, kenar boyunca IO bağlantıları ve soğutma sistemi entegrasyonu için bir çengelli bir devre kartı barındıran bir modül. IBM ana bilgisayarlarında kullanılıyor Daha fazla bilgi: http://ewh.ieee.org/soc/cpmt/presentations/cpmt0810a.pdf "}

lscpu CPU mimarisi bilgi formu / proc / cpuinfon'u insan tarafından okunabilen biçimde toplar:

# 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

Ayrıca bkz . Https://unix.stackexchange.com/questions/468766/understanding-output-of-lscpu .

Bu benim için çalıştı. tail -nXyalnızca son X satırını yakalamanızı sağlar.

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

Hiper iş parçacığınız varsa, bu fiziksel çekirdeklerin sayısını yakalamak için işe yaramalıdır.

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

Toplam fiziksel çekirdek sayısı için:

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

Çok soketli makinelerde (veya her zaman), yukarıdaki sonucu soket sayısı ile çarpın:

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

@ mklement0, lscpu kullanarak oldukça hoş bir cevabı var. Yorumlarda daha özlü bir versiyon yazdım

Ayrıca Python kullanabilirsiniz! Fiziksel çekirdek sayısını elde etmek için:

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

Hiper iş parçacıklı çekirdeklerin sayısını almak için:

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

Linux, MacOS, Windows için platformlar arası çözüm:

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

Linux'ta çevrimiçi olan fiziksel çekirdek sayısını saymak için kullandığım yol şu şekildedir:

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

ya da kısaca:

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

Örnek (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

Örnek (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

Örnek (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

Getconf kullanmak gerçekten en taşınabilir yöntemdir, ancak değişkenin BSD ve Linux'ta getconf için farklı adları vardır, bu nedenle bu özetin önerdiği gibi her ikisini de test etmeniz gerekir: https://gist.github.com/jj1bdx/5746298 (ayrıca içerir) ksh kullanarak bir Solaris düzeltmesi)

Şahsen kullanıyorum:

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

Ve bunu python'da istiyorsanız, os modülünü içe aktararak syscall getconf kullanımlarını kullanabilirsiniz:

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

Gelince nproc, GNU Coreutils'in bir parçası, bu yüzden varsayılan olarak BSD'de mevcut değil. Diğer yöntemlerden sonra sysconf () kullanır.

Bunu linux ve OS X üzerinde çalışacak şekilde yapmak istiyorsanız, şunları yapabilirsiniz:

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

O çok basit. Sadece bu komutu kullanın:

lscpu

Fiziksel CPU çekirdeği sayısını belirlemek için aşağıdaki yöntemlerden birini kullanabilirsiniz .

• Benzersiz çekirdek kimliklerinin sayısını (kabaca eşdeğer grep -P '^core id\t' /proc/cpuinfo | sort -u | wc -l) sayın .

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

• 'Soket başına çekirdek' sayısını soket sayısıyla çarpın.

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

• Linux çekirdeği tarafından kullanılan benzersiz mantıksal CPU'ların sayısını sayın. Bu -pseçenek, kolay ayrıştırma için çıktı üretir ve önceki sürümleriyle uyumludur lscpu.

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

Sadece başkalarının söylediklerini tekrarlamak için, ilgili birkaç özellik var.

Kullanılabilir işlemci sayısını belirlemek için:

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

Mevcut işleme birimi sayısını belirlemek için (göbek sayısı ile aynı olması gerekmez). Bu hiper iş parçacığının farkında.

nproc

Tavşan deliğinden çok aşağıya gitmek istemiyorum, ancak yapılandırılmış işlemci sayısını da (sadece mevcut / çevrimiçi işlemcilerin aksine) belirleyebilirsiniz getconf _NPROCESSORS_CONF. Çıktısını ayrıştırmak istediğiniz toplam CPU sayısını (çevrimdışı ve çevrimiçi) belirlemek için lscpu -ap.

Ayrıca cat /proc/cpuinfobana doğru cevabı vereceğini düşündüm , ancak yakın zamanda ARM dört çekirdekli Cortex A53 sistemimin sadece tek bir çekirdek gösterdiğini gördüm. / Proc / cpuinfo yalnızca aktif çekirdekleri gösterir, oysa:

cat /sys/devices/system/cpu/present

orada ne olduğuna dair daha iyi bir ölçüdür. Ayrıca

cat /sys/devices/system/cpu/online

hangi çekirdeklerin çevrimiçi olduğunu görmek ve

cat /sys/devices/system/cpu/offline

hangi çekirdeklerin çevrimdışı olduğunu görmek için. online, offlineVe presentbir geri dönüş değeri çok sysfs girişleri, CPU dizin dönmek 0sadece çekirdek 0 aracı bir dönüş değeri ise,1-3 araçlar çekirdekler 1,2, ve 3'te gösterilmektedir.

Bkz. Https://www.kernel.org/doc/Documentation/ABI/testing/sysfs-devices-system-cpu

Aşağıdakiler, hem hiper iş parçacıklı hem de hiper iş parçacıklı olmayan sistemdeki "gerçek" çekirdeklerin sayısını vermelidir. En azından bütün testlerimde çalıştı.

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

Web sayfam değil, http://www.ixbrian.com/blog/?p=64&cm_mc_uid=89402252817914508279022&cm_mc_sid_50200000=1450827902 adresindeki bu komut centos'ta benim için iyi çalışıyor. Hiper iş parçacığı etkinleştirilmiş olsa bile gerçek cpus'u gösterecektir.

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

"Core id" (ahududu gibi) mevcut değilse "işlemci" sayısında geri dönüş ile awk kullanarak "fiziksel id" yöntemi başına "core id" sayısını sayın (ahududu gibi)

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

Bu iyi çalıştı. İlk cevabı denediğimde çıkış olarak 3 CPU aldım. Ben sistemde 4 CPU'ları olduğunu biliyorum, bu yüzden sadece bir grepişlemci için yaptım ve çıkış şöyle görünüyordu:

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

 dmidecode  | grep -i cpu | grep Version

bana verir

Sürüm: Intel (R) Xeon (R) CPU E5-2667 v4 @ 3.20GHz

Sürüm: Intel (R) Xeon (R) CPU E5-2667 v4 @ 3.20GHz

Doğru soket sayımı hangisi - ararken E5-2667her soket vardır söylüyor 8 coresböylece çarpma ve ile bitirmek 16 coreskarşısında2 sockets .

Nerede lscpuver 20 CPUs- ki bu tamamen yanlış - neden emin değilim. (aynı şey cat /proc/cpu- sona erer 20.

Çabuk, çatalsız

Hepsi ile bu çalışma kabuk.

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

İle uyumlu kalmak için kabuk, tire, busyboxve diğerleri ncore=$((ncore+1))yerine kullandım ((ncore++)).

darbe versiyon

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

Python'u kullanmanız uygunsa, numexprmodülün bunun için bir işlevi vardır:

In [5]: import numexpr as ne

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

Ayrıca bu:

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

Bu bilgiyi komut isteminden sorgulamak için şunu kullanın:

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

Veya basitçe bu bilgiyi multiprocessing.cpu_count()fonksiyondan almak mümkündür

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

Veya daha da basitçe os.cpu_count()

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

Sadece fiziksel çekirdekleri saymak istiyorsan, bu komut benim için yaptı.

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

Oldukça basit, ancak mantıksal sayımı yok sayarak gerçek fiziksel çekirdekleri sayıyor gibi görünüyor

Python 3 ayrıca bunu elde etmek için birkaç basit yol sunar:

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

4

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

4

Temel ayrıntıları almak için aşağıdaki sorguyu kullanın

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

Özet: fiziksel CPU'ları almak için :

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

fiziksel ve mantıksal CPU'ları almak için :

grep -c ^processor /proc/cpuinfo

/proc << Bu, işlemler hakkında ihtiyacınız olan tüm bilgilerin altın kaynağıdır ve

/proc/cpuinfo << herhangi bir CPU bilgisinin altın kaynağıdır.