මගේ පද්ධතියේ හරයන් කීයක් තිබේදැයි සොයා ගැනීමට මට අවශ්‍ය විය, එබැවින් මම ගූගල් හි එකම ප්‍රශ්නය සෙව්වෙමි. මට විධානය වැනි විධාන කිහිපයක් ලැබුණා lscpu. මම මෙම විධානය උත්සාහ කළ විට, එය මට පහත ප්‍රති result ලය ලබා දුන්නේය:

$ lscpu
Architecture:          x86_64
CPU op-mode(s):        32-bit, 64-bit
Byte Order:            Little Endian
CPU(s):                4
On-line CPU(s) list:   0-3
Thread(s) per core:    1
Core(s) per socket:    4
Socket(s):             1
NUMA node(s):          1
Vendor ID:             GenuineIntel
CPU family:            6
Model:                 23
Stepping:              10
CPU MHz:               1998.000
BogoMIPS:              5302.48
Virtualization:        VT-x
L1d cache:             32K
L1i cache:             32K
L2 cache:              2048K
NUMA node0 CPU(s):     0-3

විශේෂයෙන්, මෙම ප්‍රතිදානය පෙන්වන්නේ:

• CPU (ය): 4
• සොකට්ටුවකට හරය (ය): 4
• CPU පවුල: 6

ලිනක්ස් පද්ධතියක හරය පෙන්නුම් කරන්නේ ඒවායින් කවරේද?

හරය ගණන පැවසීමට වෙනත් විධානයක් තිබේද, නැතහොත් එය සම්පූර්ණයෙන්ම වැරදියි කියා මා සිතනවාද?

ඔබ සොකට් එකකට සොකට් සහ කෝර්ස් දෙස බැලිය යුතුය. මෙම අවස්ථාවේදී ඔබට භෞතික CPU (සොකට්) 1 ක් ඇති අතර එය හර 4 ක් (සොකට්ටුවකට කෝර්) ඇත.

සම්පූර්ණ පින්තූරයක් ලබා ගැනීම සඳහා ඔබ එක් හරයකට නූල් ගණන , සොකට් එකකට හර සහ සොකට් දෙස බැලිය යුතුය . ඔබ මෙම සංඛ්‍යා ගුණ කළහොත් ඔබේ පද්ධතියේ CPU ගණන ලැබෙනු ඇත .

CPUs = සොකට් X සොකට් එකකට එක් හරයක් සඳහා හරය

CPU යනු ඔබ ධාවනය කරන විට ඔබ දකින දෙයයි htop(මේවා භෞතික CPU වලට සමාන නොවේ).

ඩෙස්ක්ටොප් යන්ත්‍රයකින් උදාහරණයක් මෙන්න:

$ lscpu | grep -E '^Thread|^Core|^Socket|^CPU\('
CPU(s):                8
Thread(s) per core:    2
Core(s) per socket:    4
Socket(s):             1

සහ සේවාදායකයක්:

$ lscpu | grep -E '^Thread|^Core|^Socket|^CPU\('
CPU(s):                32
Thread(s) per core:    2
Core(s) per socket:    8
Socket(s):             2

සිට ප්‍රතිදානය nprocCPU ගණනය කිරීමට අනුරූප වේ lscpu. මෙයට ඉහළින් ඇති ඩෙස්ක්ටොප් යන්ත්‍රය විසින් වාර්තා කරන ලද CPU (ය) 8 ට අනුරූප විය යුතුය lscpu:

$ nproc --all
8

ප්‍රතිදානය /proc/cpuinfoමෙම තොරතුරුවලට අනුරූප විය යුතුය, උදාහරණයක් ලෙස ඉහත ඩෙස්ක්ටොප් පද්ධතියේ අපට ප්‍රොසෙසර 8 ක් (සීපීයූ) සහ කෝර් 4 ක් (මූලික හැඳුනුම්පත 0-3) ඇති බව පෙනේ:

$ grep -E 'processor|core id' /proc/cpuinfo
processor   : 0
core id     : 0
processor   : 1
core id     : 0
processor   : 2
core id     : 1
processor   : 3
core id     : 1
processor   : 4
core id     : 2
processor   : 5
core id     : 2
processor   : 6
core id     : 3
processor   : 7
core id     : 3

මෙම cpu coresවිසින් වාර්තා /proc/cpuinfoකිරීමට අනුරූප Core(s) per socketවිසින් වාර්තා lscpu. මෙයට ඉහළින් ඇති ඩෙස්ක්ටොප් යන්ත්‍රය සඳහා lscpu විසින් වාර්තා කරන ලද සොකට්ටුවකට හරය (ය) 4 ට අනුරූප විය යුතුය:

$ grep -m 1 'cpu cores' /proc/cpuinfo
cpu cores   : 4

ඔබේ ප්‍රශ්නයට නිශ්චිතවම පිළිතුරු සැපයීම සඳහා ඔබ සතුව ඇති කෝර් ගණන කොපමණ දැයි කියන්න ඔබ සතුව ඇති කෝර් ගණන ඔබ සතුව ඇති සොකට් ගණන අනුව ගුණ කිරීමෙන්.

කෝර්ස් = සොකට් එකකට කෝර් එක්ස් සොකට්

උදාහරණයක් ලෙස ඩෙස්ක්ටොප් එකට ඉහළින් ඇති පද්ධති වලට හර 4 ක් ඇත:

$ echo "Cores = $(( $(lscpu | awk '/^Socket\(s\)/{ print $2 }') * $(lscpu | awk '/^Core\(s\) per socket/{ print $4 }') ))"
Cores = 4

සේවාදායකයට 16 ක් ඇති අතර

$ echo "Cores = $(( $(lscpu | awk '/^Socket\(s\)/{ print $2 }') * $(lscpu | awk '/^Core\(s\) per socket/{ print $4 }') ))"
Cores = 16

තවත් ප්‍රයෝජනවත් උපයෝගීතාවයක් වන්නේ dmidecodeසොකට් තොරතුරු සඳහා ප්‍රතිදානය කරන. ඉහත ලැයිස්තුගත කර ඇති සේවාදායක පද්ධතියේ දී අපි බලාපොරොත්තු වන්නේ සොකට්ටුවකට කෝර් 8 ක් සහ සොකට්ටුවකට නූල් 16 ක් දැකීමට ය:

$ sudo dmidecode -t 4 | grep -E 'Socket Designation|Count'
    Socket Designation: CPU1
    Core Count: 8
    Thread Count: 16
    Socket Designation: CPU2
    Core Count: 8
    Thread Count: 16

මෙම lscpuවිධානය මඟින් ඔබ උදාහරණයක් ලෙස, පරීක්ෂා කිරීමට කැමති විය හැකි ප්රයෝජනවත් විකල්ප ගණනාවක් ඇත:

$ lscpu --all --extended
$ lscpu --all --parse=CPU,SOCKET,CORE | grep -v '^#'

විස්තර man lscpuසඳහා බලන්න.

සාරාංශයකින්:

• සොකට්, කෝර් සහ නූල් ගැන ඔබ දැනුවත් විය යුතුය
• විවිධ සන්දර්භයන්හි විවිධ දේ අදහස් කරන බැවින් ඔබ CPU යන පදය ගැන සැලකිලිමත් විය යුතුය

ඔබ විසින් මෙම තොරතුරු ලබා ගත හැක nproc(1)විධාන

$ nproc --all
12

එයට මූල වරප්‍රසාද අවශ්‍ය නොවේ.

පිළිතුර අවුල් සහගත නොවීමට, ඔබ සරල පරිගණක ගෘහ නිර්මාණ සංකල්ප කිහිපයක් තේරුම් ගත යුතුය:

• ඔබ ඔබේ ලිනක්ස් පද්ධතියේ ක්‍රියාවලි ("වැඩසටහන්") ක්‍රියාත්මක කරයි. සෑම ක්‍රියාවලියක්ම නූල් එකක් හෝ වැඩි ගණනකින් සමන්විත වේ
• සෑම නූල් එකක්ම වෙනමම උපදෙස් මාලාවකි . නූල් දෙකක් සමාන්තරව ක්‍රියාත්මක කළ හැකිය.
• සෑම උපදෙස්ම ක්‍රියාත්මක කිරීමට CPU එකකට දෙනු ලැබේ. CPU හි තර්කනය ඇත, එය උපදෙස් වල බිටු වල තේරුම කුමක්ද සහ එය සමඟ කළ යුත්තේ කුමක්ද යන්න තීරණය කරයි.

• විවිධ වර්ගයේ උපදෙස් තිබේ. CPU තුළ ඇති තීරණ ගැනීමේ තර්කනය විවිධ දෘඩාංග ඒකක වෙත විවිධ උපදෙස් යවනු ඇත . නිදසුනක් ලෙස, ගණිත උපදෙස් ඇත්ත වශයෙන්ම ALU (අංක ගණිත / තාර්කික ඒකකය) විසින් සිදු කරනු ලබන අතර , මතකයෙන් පැටවීම / ගබඩා කිරීම සඳහා වන උපදෙස් යම් ආකාරයක මතක ඒකකයක් මඟින් ක්‍රියාත්මක වේ.

• ඒ හරය සැබෑ ක්රියාත්මක දෘඩාංග (එනම් සෑම ප්රධාන ආදිය සඳහා අලු, මතකයන් ඒකකය ඇත ...) මාලාවක් හඳුන්වා

• ඔබට එක් හරයක් බෙදා ගන්නා බහු CPU තිබිය හැකිය - මෙය හයිපර්ට්‍රෙඩින් ලෙස හැඳින්වේ.

  • අදහස: නූල් A දැනට අංක ගණිතය කරමින් සිටින අතර B නූල් මතකයෙන් යමක් පටවනු ලැබේ. එය සත්‍ය වූ විට, A සහ ​​B නූල් එකිනෙකාගේ මාර්ගයට නොගොස් කාර්යක්ෂමව තනි හරයක් බෙදා ගත හැකිය (A ALU භාවිතා කරයි, B මතක ඒකකය භාවිතා කරයි). ඇත්ත වශයෙන්ම, සමහර විට වැඩසටහන් දෙකටම ALU අවශ්‍ය වනු ඇත, එවිට ඔවුන් එකිනෙකා වෙනුවෙන් බලා සිටිය යුතුය ...

• ඒ අඩි, චිප්, ඇතුළු වන බවට මව් පුවරුව මත භෞතික තව් වේ. මෙම චිපය මත නිශ්චිත හර ගණනක් ඇත.

උදාහරණ:

OP හි උදාහරණය:

CPU(s):                4
Thread(s) per core:    1
Core(s) per socket:    4
Socket(s):             1

• චිපයක් අඩංගු එක් භෞතික සොකට් එකක්
• භෞතික හර 4 ක් (සිතන්න ALUs 4 ක් සහ මතක ඒකක 4 ක්)
• හරයකට උපදෙස් නිකුත් කළ හැක්කේ නූල් 1 කට පමණි (අධි තෙරපුමක් නැත), එයින් අදහස් වන්නේ පවතී
• හරයකට එක් CPU එකක් හෝ 4 * 1 = 4 CPUs

තවත් උදාහරණයක්:

CPU(s):                16
Thread(s) per core:    2
Core(s) per socket:    4
Socket(s):             2

භෞතික සොකට් දෙකක්, සෑම එකක්ම භෞතික හර 4 ක් සහිත චිපයක් අඩංගු වන අතර එමඟින් සම්පූර්ණ හර 8 ක් සෑදී ඇත. එක් එක් හරයට උපදෙස් නිකුත් කිරීමට නූල් දෙකක් ලබා ගනී (මෙම යන්ත්‍රයට අධි තෙරපුමක් ඇත), එයින් අදහස් වන්නේ එක් එක් හරයට CPU දෙකක් අමුණා තිබිය යුතු අතර එමඟින් මුළු 8 * 2 = 16 CPUs

පළමු යන්ත්‍රය ඕනෑම වේලාවක, කාල පරිච්ඡේදයකදී උපදෙස් හතරක් හරියටම ක්‍රියාත්මක කළ හැකිය. දෙවන යන්ත්‍රයට ඕනෑම වේලාවක උපදෙස් 8 ත් 16 ත් අතර ප්‍රමාණයක් ක්‍රියාත්මක කළ හැකිය: 16 ලබා ගත හැක්කේ සෑම CPU යුගලයක්ම විවිධ ආකාරයේ උපදෙස් ක්‍රියාත්මක කරන විට පමණක් වන අතර එමඟින් බලා නොසිට හරයක් බෙදා ගත හැකිය.

cat /proc/cpuinfoඑක් එක් හරය සඳහා දත්ත කැබැල්ලක් ප්‍රතිදානය කරන විධානය ද ඔබට භාවිතා කළ හැකිය . සෑම කැබැල්ලක්ම ආරම්භ වන්නේ මෙම තොරතුරු සමඟ ය:

processor   : 3
vendor_id   : GenuineIntel
cpu family  : 6
model       : 60
model name  : Intel(R) Core(TM) i5-4210M CPU @ 2.60GHz
(...)

0 සිට ඇරඹෙන පරිදි හරය අංකනය කර ඇත, එබැවින් processor : 3මෙම අවස්ථාවෙහිදී මෙන් අවසාන කැබැල්ල පවසන්නේ නම්, ඔබේ යන්ත්‍රයට හර 4 ක් ඇත.

getconf _NPROCESSORS_ONLN

(getconf යනු glibc හි කොටසකි)

[root@xxxxx ~]#  dmidecode -t 4 | egrep -i "Designation|Intel|core|thread"
    Socket Designation: CPU1
    Manufacturer: Intel
            HTT (Multi-threading)
    Version: Intel(R) Xeon(R) CPU           L5640  @ 2.27GHz
    Core Count: 6
    Core Enabled: 6
    Thread Count: 12
    Socket Designation: CPU2
    Manufacturer: Intel
            HTT (Multi-threading)
    Version: Intel(R) Xeon(R) CPU           L5640  @ 2.27GHz
    Core Count: 6
    Core Enabled: 6
    Thread Count: 12

$ grep -c processor /proc/cpuinfo
8

ඔබට අවශ්‍ය වන්නේ එපමණයි. හයිපර්ට්‍රෙඩින් සක්‍රිය හෝ අක්‍රිය වුවද එය අන්තර්ජාලයේ හරය ගණන වේ.

$ ls -d /sys/devices/system/cpu/cpu* | wc -l
8

තවත් පහසු ක්‍රමයක්.

මම මේ ආකාරයෙන් සොයාගත්තා:

echo $((`cat /sys/devices/system/cpu/present | sed 's/0-//'` + 1))

CPU පවුල මෙහි අදාල නොවේ.

• CPU (ය) = භෞතික සොකට්
• සොකට්ටුවකට හරය (ය) - එය පවසන පරිදි
• එබැවින් මුළු හර ගණන = CPU (ය) * සොකට්ටුවකට හරය (ය)

ඔබේ නඩුවේදී, ඔබට සම්පූර්ණ හර 4 ක් ඇත.

වැදගත් විය හැකි දෙය නම් “හරයකට නූල් (ය)” යන්නයි. නමුත් ඔබට 1 ක් ඇත, එබැවින් ඔබේ නඩුවේ නොවේ.

CPU ගණන ගණනය කිරීම සඳහා සරල ක්‍රමයක් වන්නේ පහත දැක්වෙන විධානයන් නිකුත් කිරීමයි:

cat /proc/interrupts | egrep -i 'cpu'