linux綁定cpu

A. linux 如何綁定指定線程在某個固定CPU上

大概的介紹一下Linux 的指定CPU運行，包括進程和線程。linux下的top命令是可以查看當前的cpu的運行狀態，按1可以查看系統有多少個CPU，以及每個CPU的運行狀態。
可是如何查看線程的CPU呢？top
-Hp pid,pid就是你當前程序的進程號，如果是多線程的話，是可以查看進程內所有線程的CPU和內存使用情況。

pstree可以查看主次線程，同樣的pstree -p pid。可以查看進程的線程情況。

taskset這個其實才是重點，可以查看以及設置當前進程或線程運行的CPU(設置親和力)。

taskset -pc pid,查看當前進程的cpu，當然有的時候不只是一個，taskset -pc cpu_num pid ,cpu_num就是設置的cpu。

這樣的話基本的命令和操作其實大家都知道了，接下來就是在代碼中完成這些操作，並通過命令去驗證代碼的成功率。

進程制定CPU運行：

[cpp] view plain
#include<stdlib.h>
#include<stdio.h>
#include<sys/types.h>
#include<sys/sysinfo.h>
#include<unistd.h>
#define __USE_GNU
#include<sched.h>
#include<ctype.h>
#include<string.h>

int main(int argc, char* argv[])
{
//sysconf獲取有幾個CPU
int num = sysconf(_SC_NPROCESSORS_CONF);
int created_thread = 0;
int myid;
int i;
int j = 0;

//原理其實很簡單，就是通過cpu_set_t進行位與操作
cpu_set_t mask;
cpu_set_t get;

if (argc != 2)
{
printf("usage : ./cpu num\n");
exit(1);
}

myid = atoi(argv[1]);

printf("system has %i processor(s). \n", num);

//先進行清空，然後設置掩碼
CPU_ZERO(&mask);
CPU_SET(myid, &mask);

//設置進程的親和力
if (sched_setaffinity(0, sizeof(mask), &mask) == -1)
{
printf("warning: could not set CPU affinity, continuing...\n");
}
while (1)
{

CPU_ZERO(&get);
//獲取當前進程的親和力
if (sched_getaffinity(0, sizeof(get), &get) == -1)
{
printf("warning: cound not get cpu affinity, continuing...\n");
}
for (i = 0; i < num; i++)
{
if (CPU_ISSET(i, &get))
{
printf("this process %d is running processor : %d\n",getpid(), i);
}
}
}
return 0;
}

進程設置CPU運行，其實只能是單線程。多線程設定CPU如下：

[cpp] view plain
#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
#include <sched.h>

void *myfun(void *arg)
{
cpu_set_t mask;
cpu_set_t get;
char buf[256];
int i;
int j;
//同樣的先去獲取CPU的個數
int num = sysconf(_SC_NPROCESSORS_CONF);
printf("system has %d processor(s)\n", num);

for (i = 0; i < num; i++) {
CPU_ZERO(&mask);
CPU_SET(i, &mask);
//這個其實和設置進程的親和力基本是一樣的
if (pthread_setaffinity_np(pthread_self(), sizeof(mask), &mask) < 0) {
fprintf(stderr, "set thread affinity failed\n");
}
CPU_ZERO(&get);
if (pthread_getaffinity_np(pthread_self(), sizeof(get), &get) < 0) {
fprintf(stderr, "get thread affinity failed\n");
}
for (j = 0; j < num; j++)
{
if (CPU_ISSET(j, &get))
{
printf("thread %d is running in processor %d\n", (int)pthread_self(), j);
}
}
j = 0;
while (j++ < 100000000) {
memset(buf, 0, sizeof(buf));
}
}
pthread_exit(NULL);
}

int main(int argc, char *argv[])
{
pthread_t tid;
if (pthread_create(&tid, NULL, (void *)myfun, NULL) != 0)
{
fprintf(stderr, "thread create failed\n");
return -1;
}
pthread_join(tid, NULL);
return 0;
}

B. 如何指定CPU只運行特定任務，linux中斷interrupt

cpuset 允許把所有進程echo到一個cpuset目錄中，與指定的cpu綁定。
The following script which is a starting point for investigating willmove all the processes to a specific cpuset with one cpu.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

if [ ! -d /sys/fs/cgroup ]; then
echo "cgroup not supported by the kernel"
else
mkdir /sys/fs/cgroup/cpuset
mount -t cgroup -ocpuset cpuset /sys/fs/cgroup/cpuset
echo 1 > /sys/fs/cgroup/cpuset/cgroup.clone_children
mkdir /sys/fs/cgroup/cpuset/cpu0
mkdir /sys/fs/cgroup/cpuset/cpu1

# assign a cpu for cgroup cpu0
echo 0 > /sys/fs/cgroup/cpuset/cpu0/cpuset.cpus

# move outself to this new cgroup
echo $$ > /sys/fs/cgroup/cpuset/cpu0/tasks
for i in $(cat /sys/fs/cgroup/cpuset/tasks); do
echo $i > /sys/fs/cgroup/cpuset/cpu0/tasks || echo "failed to add pid $i/$(cat /proc/$i/comm)"
done

# assign a cpu for cgroup cpu1
echo 1 > /sys/fs/cgroup/cpuset/cpu1/cpuset.cpus

# make cpu1 exclusive so processes belonging
# to the other cgroup won't use it
echo 1 > /sys/fs/cgroup/cpuset/cpu1/cpuset.cpu_exclusive
fi

把系統中的進程與CPU0綁定，然後把CPU1設置 exclusive屬性，這樣其它cgroup不會使用這個CPU。
開啟stress壓力測試

在此基礎上再開啟一個CPUhot：
可見新啟動的任務不會佔用CPU1。
將CPUhot進程與 CPU1綁定：
此時觀察CPU使用率：
另外還有一個問題就是怎樣禁止一個中斷打斷cpu？
內核提供了中斷的affinity，但要使用這個還需要關閉 irq balancer 進程。
如下腳本可以設置中斷的cpu affinity。

for i in $(find /proc/irq -name "smp_affinity"); do echo 1 > $i; done
以上腳本把所有中斷的CPU Affinity都設置為CPU0。
這樣在/proc/irq目錄下的每一個中斷其CPU Affinity都被設置為CPU0。
此時仍有一系列的中斷會打斷CPU1：
Single function call interrupts
Local timer interrupts

另外要讓中斷的CPU Affinity起作用，irq balance 服務必須被關閉。但這樣中斷負載平衡就被打斷，能不能修改irq balance 代碼，讓其在規定的若干個CPU核心上負責中斷平衡

C. linux程序cpu佔用率太高

如果就是佔用率太高的話，我建議你就是直接就是卸載掉，因為有的時候這種佔佔。可能太高的話，對於我們的手機來說也是不太好的。

設置角色密碼（可結合密碼保護卡）。
2、設置背包密碼，背包分二部分（G也分2部份，1大額，1小額），一部分需要密碼（可以放重要的財產），一部分不要密碼（放置常用物品），可結合密保卡。
3、裝備欄設置密碼保護卡，上線後需要輸入密保卡解除裝備欄的密報卡數，才能使用技能 ，如果不解除綁定，不能使用技能並且無法交易。
4、倉庫通過密碼打開後，與背包相同。
5、設置退出密碼，輸入退出密碼正常才能下線，非正常下線5分內補能登陸。設置下次登陸地點，玩家下線時可以選者下次登陸的IP段（以市為單位，不在IP段裡面的IP，不能登陸 ）
6、計算機綁定，對於有計算機的玩家可以綁定CPU編號，這點某些殺毒軟體有這個技術，你們估計也有這技術。
強固密碼內容
一個強固的密碼至於要有下列四方面內容的三種：
·大寫字母
·小寫字母
·數字
·非字母數字的字元，如標點符號
.特殊符號，多國數字
強壯密碼
大多數情況下，僅養成使用好密碼的習慣是不夠的；你還需要使用更強壯的密碼來有效阻止類似於字典攻擊和暴力破解攻擊。我們前面已經討論，一個強壯的密碼至少需要六個字元，不能包括用戶名的任何一部分，並且至少要有大小寫字母、數字和通配符等。為了實施強壯的密碼你需要在注冊表裡LSA項加入本課已提過的其它的密碼過濾器。在主域控制器或在任一可能會升級為主域控制器的備份域控制器上，你都需要在注冊表HKLM\System\CurrentControlSet\Control\LSA中加入PASSFILT的字串。
大漏洞
在Windows2000啟動之後，按照屏幕提示按下ALT+CTRL+DEL進行登錄，在登錄界面將游標移至用戶名輸入框，按鍵盤上的Ctrl+Shift鍵進行輸入法的切換，屏幕上出現輸入法狀態條，在出現的「全拼」輸入法中將滑鼠移至輸入法狀態條點擊滑鼠右鍵，出現的選單中選擇「幫助」，然後繼續選擇「輸入法入門」，在窗口頂部會出現幾個按鈕，奧妙就在「選項按鈕」上。如果系統是未安裝Windows2000 ServicePack1或IE5.5的系統，用滑鼠左鍵點擊選項按鈕，在出現的選單中選擇「主頁」，這時在已出現的幫助窗口的右側會出現IE瀏覽器界面中的「此頁不可顯示」頁面，其中有個「檢測網路設置」的鏈接，點擊它就會出現網路設置選項，這樣任何人都可以對網路設置甚至控制面板做任何修改。
或者之前用滑鼠左鍵點擊「選項」按鈕時，在出現的選單選擇「Internet選項」中，就可以對主頁、鏈結，安全、高級選項等做任何修改。最為嚴重的是用滑鼠右鍵點擊先前提到的「選項」按鈕會出現一個選單，選擇「跳至URL」，這時出現一個對話框，其中有一個跳至該URL輸入框，輸入你想看到的路徑，比如c:，那麼這時在已出現的幫助窗口的右側會出現資源管理器c盤的界面顯示，這時已經是系統管理員許可權對C盤進行操作了。操作者可以對看到的數據做任何的操作，這樣他就完全繞過了Windows2000的登錄驗證機制

D. linux查看中斷綁定在哪個cpu

cpuset 允許把所有進程echo到一個cpuset目錄中，與指定的cpu綁定。 The following script which is a starting point for investigating willmove all the processes to a specific cpuset with one cpu. if [ ! -d /sys/fs/cgroup ]; then echo...

E. 將進程綁定到指定的CPU上

背景：為什麼要進程綁定到指定的CPU上？

1) 減少CPU切換開銷

CPU固定綁定到主機的指定CPU上，在整個運行期間，不會發生CPU浮動， 減少CPU切換開銷 ，提高虛擬機的計算性能。

2) 提供CPU cache的命中率

在多核運行的機器上，每個CPU自身會有緩存，緩存著進程使用的信息，而進程可能會被OS調度到其他CPU上，如此， CPU cache命中率 就低了，當綁定CPU後，程序就會一直在指定的cpu跑，不會由操作系統調度到其他CPU上，性能有一定的提高。

taskset：設置或檢索進程的CPU相關性

1) 如果沒有taskset命令， 安裝 包含taskset命令的util-linux工具集：yum install util-linux

2) 查看進程的CPU親和力 ，-p選項是一個十六進制數，-cp選項是一個cpu列表，表示相應的cpu核。3的二進制形式是0011，相應的第0位和第1位都是1，表示14795進程只能運行在cpu的第0個核和第1個核。

$ taskset -p 14795

pid 14795's current affinity mask: 3

$ taskset -cp 14795

pid 14795's current affinity list: 0,1

3) 綁定CPU ： taskset -cp <CPU IDs>  <Process ID>

$ taskset -cp  0  14795

pid 14795's current affinity list: 0,1

pid 14795's new affinity list: 0

OpenStack K版本引入了許多CPU高級特性功能，不僅支持自定義CPU拓撲功能，支持設置虛擬機CPU的socket、core、threads等，還支持CPU pinning功能，即CPU核綁定，甚至能夠配置虛擬機獨占物理CPU，虛擬機的vCPU能夠固定綁定到物理宿主機的指定pCPU上，在整個運行期間，不會發生CPU浮動，減少CPU切換開銷，提高虛擬機的計算性能。

$ lscpu

Architecture:          x86_64

CPU op-mode(s):        32-bit, 64-bit

Byte Order:            Little Endian

CPU(s):                40

On-line CPU(s) list:  0-39

Thread(s) per core:    2

Core(s) per socket:    10

Socket(s):            2

NUMA node(s):          2

Vendor ID:            GenuineIntel

CPU family:            6

Model:                63

Model name:            Intel(R) Xeon(R) CPU E5-2650 v3 @ 2.30GHz

Stepping:              2

CPU MHz:              1201.480

BogoMIPS:              4603.87

Virtualization:        VT-x

L1d cache:            32K

L1i cache:            32K

L2 cache:              256K

L3 cache:              25600K

NUMA node0 CPU(s):    0,2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32,34,36,38

NUMA node1 CPU(s):    1,3,5,7,9,11,13,15,17,19,21,23,25,27,29,31,33,35,37,39

以上可知，該宿主機有兩個CPU(socket)，每個CPU 10核(core)，每個核可以開啟兩個 超線程(thread) ，即有40個邏輯CPU。宿主機CPU包含兩個NUMA node，其中node0包括0，2，4，...,38，node1包括1,3,5,...,39。

步驟1) 創建支持綁核的主機集合

不是所有的計算節點都支持CPU綁核特性，可以通過主機集合(host aggregate)把支持綁核CPU的主機放到一個集合中。

步驟2)  創建支持綁核的flavor

目前Nova並不支持啟動時直接指定主機集合的metadata(hint只支持指定server group)，需要通過flavor的擴展屬性和主機集合的metadata匹配，將不匹配的主機濾掉，部署到匹配的主機上。flavor支持配置虛擬機的CPU拓撲、QoS、CPU pinning策略、NUMA拓撲以及PCI passthrough等擴展屬性。

步驟3) 通過步驟2) 的Flavor創建虛擬機，創建完成到虛機所在物理機上查看虛機綁核情況：

查詢方法1) virsh mpxml 虛機id

<vcpu placement='static'>8</vcpu>

<cputune>

<vcpupin vcpu='0' cpuset='25'/>

<vcpupin vcpu='1' cpuset='5'/>

<vcpupin vcpu='2' cpuset='8'/>

<vcpupin vcpu='3' cpuset='28'/>

<vcpupin vcpu='4' cpuset='9'/>

<vcpupin vcpu='5' cpuset='29'/>

<vcpupin vcpu='6' cpuset='24'/>

<vcpupin vcpu='7' cpuset='4'/>

<emulatorpin cpuset='4-5,8-9,24-25,28-29'/>

</cputune>

查詢方法2) 在虛擬機所運行的物理宿主機上執行virsh list找到相應虛機的實例id，然後virsh vcpupin 實例id可以查到該虛擬機所佔用的CPU具體核數。

# virsh vcpupin vm46  綁核的虛機

VCPU: CPU Affinity

----------------------------------

  0: 25

  1: 5

  2: 8

  3: 28

  4: 9

  5: 29

  6: 24

  7: 4

# virsh vcpupin vm6 未綁核的虛機

VCPU: CPU Affinity

----------------------------------

  0: 0-39 

  1: 0-39

  2: 0-39 

  3: 0-39

  4: 0-39 

  5: 0-39

  6: 0-39 

  7: 0-39

virsh vcpupin 子命令是KVM自帶的指令工具，它可以把vm實例的每個vcpu與宿主機的cpu對應綁定，這種綁定方式粒度更小。

# virsh vcpupin vm4 查看綁定情況

VCPU: CPU Affinity

----------------------------------

  0: 0-23     

  1: 0-23

#默認2個vcpu沒有進行綁定，可以在0-23號cpu上切換

# virsh vcpuinfo vm4 查看CPU使用時長

VCPU:          0

CPU:            10  #運行在10號cpu上

State:          running

CPU time:      14.2s

CPU Affinity:  yyyyyyyyyyyyyyyyyyyyyyyy

VCPU:          1

CPU:            8      #運行在8號cpu上

State:          running

CPU time:      6.8s

CPU Affinity:  yyyyyyyyyyyyyyyyyyyyyyyy

# virsh vcpupin vm4 0 3 綁定虛機的第1個CPU到宿主機的第4號cpu上

# virsh vcpupin vm4 1 5 綁定虛機的第2個CPU到宿主機的第6號cpu上

# virsh vcpuinfo vm4

VCPU:          0

CPU:            3

State:          running

CPU time:      14.5s

CPU Affinity:  ---y--------------------

VCPU:          1

CPU:            5

State:          running

CPU time:      7.3s

CPU Affinity:  -----y------------------

# virsh vcpupin vm4

VCPU: CPU Affinity

----------------------------------

  0: 3

  1: 5

三種方法的相同點：都能實現綁核效果

優劣勢對比：openstack支持虛機重生虛擬遷移到其他物理主機上，第1種方法在這些操作後綁核還是有效的，但2和3就不會綁核的。此外，第1種方法是自動的，2和3是手動的，可以作為臨時補救方法。

在虛擬機上執行高密度計算，測試的python腳本如下:

# test_compute.py

k = 0

for i in xrange(1, 100000):

    for j in xrange(1, 100000):

        k = k + i * j

使用shell腳本同時跑50個進程，保證CPU滿載運行:

for i in `seq 1 50`; do

    python test_compute.py &

done

使用sar命令查看宿主機CPU使用情況:

sar -P ALL 1 100

結果如下:

Linux 3.10.0-229.20.1.el7.x86_64 (8409a4dcbe1d11af)    05/10/2018      _x86_64_        (40 CPU)

10:20:14 PM    CPU    %user    %nice  %system  %iowait    %steal    %idle

10:20:15 PM    all    20.48      0.00      0.15      0.03      0.00    79.34

10:20:15 PM      0      0.00      0.00      0.00      0.00      0.00    100.00

10:20:15 PM      1      0.99      0.00      0.00      0.00      0.00    99.01

10:20:15 PM      2      0.00      0.00      0.00      0.00      0.00    100.00

10:20:15 PM      3      0.00      0.00      0.00      0.00      0.00    100.00

10:20:15 PM      4    100.00      0.00      0.00      0.00      0.00      0.00

10:20:15 PM      5    100.00      0.00      0.00      0.00      0.00      0.00

10:20:15 PM      6      0.00      0.00      0.00      0.00      0.00    100.00

10:20:15 PM      7      0.00      0.00      0.00      0.00      0.00    100.00

10:20:15 PM      8    100.00      0.00      0.00      0.00      0.00      0.00

10:20:15 PM      9    100.00      0.00      0.00      0.00      0.00      0.00

10:20:15 PM      10      1.01      0.00      0.00      0.00      0.00    98.99

10:20:15 PM      11      1.00      0.00      0.00      0.00      0.00    99.00

10:20:15 PM      12      0.00      0.00      0.00      0.00      0.00    100.00

10:20:15 PM      13      0.00      0.00      0.99      0.00      0.00    99.01

10:20:15 PM      14      0.99      0.00      0.99      0.00      0.00    98.02

10:20:15 PM      15      1.00      0.00      0.00      0.00      0.00    99.00

10:20:15 PM      16      0.99      0.00      0.99      0.00      0.00    98.02

10:20:15 PM      17      0.00      0.00      0.00      0.00      0.00    100.00

10:20:15 PM      18      0.00      0.00      0.00      0.00      0.00    100.00

10:20:15 PM      19      3.96      0.00      0.99      0.00      0.00    95.05

10:20:15 PM      20      0.00      0.00      0.00      0.00      0.00    100.00

10:20:15 PM      21      0.00      0.00      0.00      0.00      0.00    100.00

10:20:15 PM      22      0.00      0.00      0.00      0.00      0.00    100.00

10:20:15 PM      23      0.00      0.00      0.00      0.00      0.00    100.00

10:20:15 PM      24    100.00      0.00      0.00      0.00      0.00      0.00

10:20:15 PM      25    100.00      0.00      0.00      0.00      0.00      0.00

10:20:15 PM      26      0.00      0.00      0.00      0.00      0.00    100.00

10:20:15 PM      27      0.00      0.00      0.00      0.00      0.00    100.00

10:20:15 PM      28    100.00      0.00      0.00      0.00      0.00      0.00

10:20:15 PM      29    100.00      0.00      0.00      0.00      0.00      0.00

10:20:15 PM      30      2.00      0.00      0.00      0.00      0.00    98.00

10:20:15 PM      31      0.00      0.00      0.00      0.00      0.00    100.00

10:20:15 PM      32      2.97      0.00      0.99      0.00      0.00    96.04

10:20:15 PM      33      0.00      0.00      0.00      0.00      0.00    100.00

10:20:15 PM      34      0.00      0.00      0.00      0.00      0.00    100.00

10:20:15 PM      35      1.00      0.00      0.00      0.00      0.00    99.00

10:20:15 PM      36      0.00      0.00      0.00      0.00      0.00    100.00

10:20:15 PM      37      0.00      0.00      0.00      0.00      0.00    100.00

10:20:15 PM      38      0.00      0.00      0.00      0.00      0.00    100.00

10:20:15 PM      39      0.00      0.00      0.00      0.00      0.00    100.00

從CPU使用情況看宿主機的pCPU 4-5，8-9，24-25，28-29使用率100%，並且整個過程中沒有浮動，符合我們的預期結果，說明CPU核綁定成功。

F. 如何將一個進程（線程）綁定到一個固定的CPU

第一種：linux的shell命令行方式，命令名字為taskset。第二種就是代碼實現級別的了，pthread_setaffinity_np和sched_setaffinity函數介面。
第一種方式我已經驗證過了，確實可行。同時驗證了我心中的疑問：如果將某個線程綁定到某個物理核上之後，在此線程運行結束前，會不會有別的線程被調度到此物理核上執行？ 寫了一個死循環驗證了下，發現綁定之後是不會調度別的線程在此核上運行的！（肉眼觀察的，時不時觀察下，沒發現別的線程在此核上執行；對比了下沒有綁定的情況，會發現過段時間此線程就會被調度到別的核心上執行）
此種方式有個問題，就是只有線程運行起來後才會被綁定到某個核上，不夠及時。
具體的方式為：
1.首先根據系統的差別運行如下安裝命令：
sudo apt-get install util-linux （Debian，Ubuntu or Linux Mint）
sudo yum install util-linux （Fedora，CentOS or RHEL）
2.相關命令的使用：
2.1 使用命令 taskset -p <PID> 來獲得此Process的 CPU affinity。
eg: taskset -p 2915 ------> pid 2915's current affinity mask:ff； ff=="1111 1111"，沒一個1代表一個核，共8個核，能用的核數也為8個核。
2.2 使用命令 taskset -cp <PID> 可獲得數字形式的CPU affinity。
eg: taskset -cp 2915 ------> pid 2915's current affinity list: 0--7。
接下來為將進程pin到某個核上的命令；
2.3 taskset -p <COREMASK> <PID>
eg:taskset -p 0x11 9030 ------>pid 9030's current affinity mask: ff ， pid 9030's new affinity mask: 11 。意思就是將此進程綁定到了CPU core 0 and 4。
2.4 taskset -cp <CORE-LIST> <PID>
eg:taskset -cp 0,4 9030 ------>the same as below.
With "-c" option, you can specify a list of numeric CPU core IDs separated by commas, or even include ranges (e.g., 0,2,5,6-10).

2.5 taskset <COREMASK> <EXECUTABLE>
eg: taskset 0x1 xxxx ----->"xxxx" represented the name of one program.
另外：參考文章最後的位置說到，綁定到此物理核之後，別的進程（線程）還可以調度到此核上執行，但是沒說綁定的這個線程沒執行完之前是否會被別的線程擠掉。根據我的觀察是不會被擠掉，這我在文章的開頭也有提到。

G. linux下怎麼解除中斷和cpu綁定

在多 CPU 的環境中，還有一個中斷平衡的問題，比如，網卡中斷會教給哪個 CPU 處理，這個參數控制哪些 CPU 可以綁定 IRQ 中斷。其中的 {number} 是對應設備的中斷編號，可以用下面的命令找出： cat /proc/interrupt 比如，一般 eth0 的 IRQ

H. linux cpu隔離和qemu中cpu綁定試驗

查看當前qemu進程(pid:1406)的cpu(psr)使用情況：

$ps -o pid,command,psr -q 1406

proc文件系統中cpu允許調度信息

$cat /proc/1406/status    

Cpus_allowed: 8

Cpus_allowed_list:      3

綁定至某個cpu：

$taskset -cp 2 1406

cpu隔離（獨占）試驗：

在linux啟動時加isocpu即可：

kernel ....  root=...  isolcpu=2,3

啟動時，默認進程就不會調度到2，3號cpu上

再加上前面的taskset，就可以控制某些cpu個某些進程獨占

I. Linux 進程、線程和CPU的關系，cpu親和性

1、物理CPU數：機器主板上實際插入的cpu數量，比如說你的主板上安裝了一塊8核CPU，那麼物理CPU個數就是1個，所以物理CPU個數就是主板上安裝的CPU個數。

2、物理CPU核數：單個物理CPU上面有多個核，物理CPU核數=物理CPU數✖️單個物理CPU的核
3、邏輯CPU核數：一般情況，我們認為一顆CPU可以有多個核，加上intel的超線程技術(HT), 可以在邏輯上再分一倍數量的CPU core出來。邏輯CPU核數=物理CPU數✖️單個物理CPU的核*2
4、超線程技術(Hyper-Threading)：就是利用特殊的硬體指令，把兩個邏輯CPU模擬成兩個物理CPU，實現多核多線程。我們常聽到的雙核四線程/四核八線程指的就是支持超線程技術的CPU。

1、並行：兩件（多件）事情在同一時刻一起發生。
2、並發：兩件（多件）事情在同一時刻只能有一個發生，由於CPU快速切換，從而給人的感覺是同時進行。
3、進程和線程
進程是資源分配的最小單位，一個程序有至少一個進程。線程是程序執行的最小單位。一個進程有至少一個線程。
線程之間的通信更方便，同一進程下的線程共享全局變數、靜態變數等數據，而進程之間的通信需要以通信的方式（IPC)進行。多進程程序更健壯，多線程程序只要有一個線程死掉，整個進程也死掉了，而一個進程死掉並不會對另外一個進程造成影響，因為進程有自己獨立的地址空間。
4、單核多線程：單核CPU上運行多線程， 同一時刻只有一個線程在跑，系統進行線程切換，系統給每個線程分配時間片來執行，看起來就像是同時在跑， 但實際上是每個線程跑一點點就換到其它線程繼續跑。
5、多核多線程：每個核上各自運行線程，同一時刻可以有多個線程同時在跑。

1、對於單核：多線程和多進程的多任務是在單cpu交替執行（時間片輪轉調度，優先順序調度等），屬於並發
2、對於多核：同一個時間多個進程運行在不同的CPU核上，或者是同一個時間多個線程能分布在不同的CPU核上（線程數小於內核數），屬於並行。
3、上下文切換：上下文切換指的是內核（操作系統的核心）在CPU上對進程或者線程進行切換。上下文切換過程中的信息被保存在進程式控制制塊（PCB-Process Control Block）中。PCB又被稱作切換幀（SwitchFrame）。上下文切換的信息會一直被保存在CPU的內存中，直到被再次使用。

CPU 親和性（affinity）就是進程要在某個給定的 CPU 上盡量長時間地運行而不被遷移到其他處理器的傾向性。這樣可以減少上下文切換的次數，提高程序運行性能。可分為：自然親和性和硬親和性
1、自然親和性：就是進程要在指定的 CPU 上盡量長時間地運行而不被遷移到其他處理器，Linux 內核進程調度器天生就具有被稱為 軟 CPU 親和性（affinity） 的特性，這意味著進程通常不會在處理器之間頻繁遷移。這種狀態正是我們希望的，因為進程遷移的頻率小就意味著產生的負載小。Linux調度器預設就支持自然CPU親和性(natural CPU affinity): 調度器會試圖保持進程在相同的CPU上運行。
2、硬親和性：簡單來說就是利用linux內核提供給用戶的API，強行將進程或者線程綁定到某一個指定的cpu核運行。Linux硬親和性指定API：taskset .

taskset [options] mask command [arg]...
taskset [options] -p [mask] pid

taskset 命令用於設置或者獲取一直指定的 PID 對於 CPU 核的運行依賴關系。也可以用 taskset 啟動一個命令，直接設置它的 CPU 核的運行依賴關系。

CPU 核依賴關系是指，命令會被在指定的 CPU 核中運行，而不會再其他 CPU 核中運行的一種調度關系。需要說明的是，在正常情況下，為了系統性能的原因，調度器會盡可能的在一個 CPU 核中維持一個進程的執行。強制指定特殊的 CPU 核依賴關系對於特殊的應用是有意義的
CPU 核的定義採用位定義的方式進行，最低位代表 CPU0，然後依次排序。這種位定義可以超過系統實際的 CPU 總數，並不會存在問題。通過命令獲得的這種 CPU 位標記，只會包含系統實際 CPU 的數目。如果設定的位標記少於系統 CPU 的實際數目，那麼命令會產生一個錯誤。當然這種給定的和獲取的位標記採用 16 進制標識。
0x00000001
代表 #0 CPU
0x00000003
代表 #0 和 #1 CPU
0xFFFFFFFF
代表 #0 到 #31 CPU

-p, --pid
對一個現有的進程進行操作，而不是啟動一個新的進程
-c, --cpu-list
使用 CPU 編號替代位標記，這可以是一個列表，列表中可以使用逗號分隔，或者使用 "-" 進行范圍標記，例如：0,5,7,9
-h, --help
列印幫助信息
-V, --version
列印版本信息

如果需要設定，那麼需要擁有 CAP_SYS_NICE 的許可權；如果要獲取設定信息，沒有任何許可權要求。

taskset 命令屬於 util-linux-ng 包，可以使用 yum 直接安裝。

J. linux下把進程/線程綁定到特定cpu核上運行

你那個是系統下把CPU的核說釘在五河以下是比較好的，因為吧和內心壓力非常大，發熱量非常大。