Linux下将进程/线程绑定到指定CPU核运行

线程绑核的简单操作 为了加快程序的运行速度和充分利用CPU资源,我们可以人为将不同线程绑定在不同的cup上,例如有两个线程A,B,其中A已经在CPU0上运行,并且CPU0上还有其他的任务,那么我们可以将线程B绑到CPU1上,这样就可以减轻CPU0的负担,从而充分利用多核CPU。说的明白点,原来是一个CPU作两件事,现在两个CPU同时做两个时,使效率更高。 话不多说,直接上代码: #define _GNU_SOUR 阅读详情
AI摘要

本文详细介绍了如何在Linux系统中查看CPU核数、物理CPU个数、逻辑CPU数,以及通过任务集(taskset)、sched_setaffinity和pthread_setaffinity_np进行进程线程与CPU核的绑定。涵盖了命令行工具、系统调用和编程示例,适合深入理解Linux调度和性能优化。

如何查看Linux核数

$ 总核数 = 物理CPU个数 X 每颗物理CPU的核数
$ 总逻辑CPU数 = 物理CPU个数 X 每颗物理CPU的核数 X 超线程数

$ 查看物理CPU个数
cat /proc/cpuinfo| grep "physical id"| sort| uniq| wc -l

$ 查看每个物理CPU中core的个数(即核数)
cat /proc/cpuinfo| grep "cpu cores"| uniq

$ 查看逻辑CPU的个数
cat /proc/cpuinfo| grep "processor"| wc -l

processor:指明每个物理CPU中逻辑处理器信息(序号:0~5表示有6个逻辑CPU)

cpu cores:指明每颗物理CPU中总核数
 

以I5-8400 6核/6线程为例:

WINDOWS查看方式:

C:\Users\Administrator>wmic

wmic:root\cli>cpu get

NumberOfCores     NumberOfEnabledCore     NumberOfLogicalProcessors

(CPU核心数)=6       (可用的CPU核心数)=6        (CPU线程数)=6

LINUX虚拟机:

$ cat /proc/cpuinfo | grep "physical id" | uniq
physical id     : 0

$ cat /proc/cpuinfo | grep "cpu cores" | uniq
cpu cores       : 6

$  cat /proc/cpuinfo | grep "processor" | uniq
processor       : 0
processor       : 1
processor       : 2
processor       : 3
processor       : 4
processor       : 5

在程序中使用系统调用sysconf获取cpu核心数:

#include <unistd.h>

int sysconf(_SC_NPROCESSORS_CONF);/* 返回系统可以使用的核数,但是其值会包括系统中禁用的核的数目,因 此该值并不代表当前系统中可用的核数 */
int sysconf(_SC_NPROCESSORS_ONLN);/* 返回值真正的代表了系统当前可用的核数 */

/* 以下两个函数与上述类似 */
#include <sys/sysinfo.h>

int get_nprocs_conf (void);/* 可用核数 */
int get_nprocs (void);/* 真正的反映了当前可用核数 */
 

C语言代码如下:

#include <stdio.h>
#include <unistd.h>
#include <sys/sysinfo.h>

int main(int argc, char *argv[])
{
        int sc_nprocessor_conf = sysconf(_SC_NPROCESSORS_CONF);
        int sc_nprocessor_onln = sysconf(_SC_NPROCESSORS_ONLN);
        printf("sc_nprocessor_conf[%d]\n", sc_nprocessor_conf);
        printf("sc_nprocessor_onln[%d]\n", sc_nprocessor_onln);
    
        int nprocs_conf = get_nprocs_conf();
        int nprocs_onln = get_nprocs();
        printf("nprocs_conf[%d]\n", nprocs_conf);
        printf("nprocs_onln[%d]\n", nprocs_onln);
        return 0;
}

执行结果:

sc_nprocessor_conf[6]
sc_nprocessor_onln[6]
nprocs_conf[6]
nprocs_onln[6]

确定调用线程正在运行的CPU和NUMA节点

#include <linux/getcpu.h>
int getcpu(unsigned *cpu, unsigned *node, struct getcpu_cache *tcache);
成功时返回0。 出错时,返回-1,并适当地设置errno
注意:这个系统调用没有glibc包装。 见注意事项。
测试程序:

#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/syscall.h>
#include <time.h>
#include <sys/types.h>

struct getcpu_cache
{
        unsigned long blob[128/sizeof(long)];
};

int getcpu(unsigned *cpu, unsigned *node,struct getcpu_cache *tcache)
{
        return syscall(SYS_getcpu, cpu, node, tcache);
}

int main(int argc, char *argv[])
{
        unsigned cpu  = 0;
        unsigned node = 0;
        if(getcpu(&cpu,&node,NULL)==-1)
        {
                printf("getcpu bad \n");
                return 1;
        }
        printf("cpu = %u node = %u\n",cpu,node);
        return 0;
}

        getcpu()系统调用标识调用线程或进程当前正在运行的处理器和节点,并将它们写入由cpu和node参数指向的整数。处理器是识别CPU的唯一小整数。该节点是标识NUMA节点的唯一小标识符。当cpu或节点为NULL时,没有任何内容写入相应的指针。
        这个系统调用的第三个参数现在是未使用的,应该指定为NULL,除非需要可移植到Linux 2.6.23或更早版本(请参阅NOTES)。

        保存在cpu中的信息仅在调用时保持为当前状态:除非使用sched_setaffinity(2)修复了CPU关联性,否则内核可能随时更改CPU。
(通常情况下不会发生这种情况,因为调度器会尽量减少CPU之间的移动来保持缓存热度,但这是可能的。)调用者必须允许在调用返回时,在cpu和node中返回的信息不再是当前的

什么是绑核

        所谓绑核,其实就是设定某个进程/线程与某个CPU核的亲和力(affinity)。设定以后,Linux调度器就会让这个进程/线程只在所绑定的核上面去运行。但并不是说该进程/线程就独占这个CPU的核,其他的进程/线程还是可以在这个核上面运行的。

掩码形式绑核

        将掩码转换为二进制形式,从最低位到最高位代表物理CPU的#0、#1、……、#n号核。某位的值为0表示不绑该核,1表示绑。比如:0x00000001的二进制为0000...0001,只有第0号核的位置是1,所以表示只绑0号核;0x00000003的二进制为0000...0011,第0和1号核的位置是1,所以表示绑CPU的0号和1号核;再比如0xFFFFFFFF的二进制为1111...1111,所有32个核的位置都为1,所以表示绑CPU的0~31核。

掩码形式的绑核命令为:

taskset -p mask pid

列表形式

        列表形式指直接指定要绑的CPU核的列表,列表中可以有一个或多个核。具体语法如下:

taskset -cp cpu-list pid

其中cpu-list是数字化的cpu列表,从0开始。多个不连续的cpu可用逗号连接,连续的可用短现连接,比如0,1,3-6等。

比如taskset -cp 0,1,3-6 2677 命令表示将进程2677 绑定到#0、#1、#3~#6号核上面。

多进程和多线程在cpu核上运行分析:

        每个 CPU 核运行一个进程的时候,由于每个进程的资源都独立,所以 CPU 核心之间切换的时候无需考虑上下文。
        每个 CPU 核运行一个线程的时候,有时线程之间需要共享资源,所以这些资源必须从 CPU 的一个核心被复制到另外一个核心,这会造成额外的开销。

举例如下:

1, 使用taskset指令绑定进程到特定CPU步骤

测试程序:cpu_processor_test.c

#include <stdio.h>
#include <time.h>
#include <sys/types.h>
#include <unistd.h>

int main(int argc, char *argv[])
{
        pid_t pid = getpid();
        pid_t ppid = getppid();
        printf("ppid %d pid %d\n", ppid, pid);
        while(1)
        {
                sleep(10);
        }
        return 0;
}

gcc cpu_processor_test.c -o cpu_processor_test

(1)获取进程pid

$ ps -aux | grep "cpu_processor_test"
myroot    1582  0.0  0.0   4352   628 pts/8    S+   22:04   0:00 ./cpu_processor_test

(2) 查看进程当前运行在哪些cpu上

$ taskset -p 1582 
pid 1582's current affinity mask: 3f

显示的十进制数字3转换为2进制为最低6个是1,每个1对应一个cpu,所以进程运行在6个cpu上。

(3)指定进程运行在cpu2上

$ taskset -pc 2 1582  
pid 1582's current affinity list: 0-5
pid 1582's new affinity list: 2

注意,cpu的标号是从0开始的,所以cpu1表示第二个cpu(第一个cpu的标号是0)。

至此,就把应用程序绑定到了cpu1上运行

(4)确认绑定命令

$ taskset -p 1582   
pid 1582's current affinity mask: 4

2,启动程序时绑定cpu

(1)启动时绑定到第3个cpu

$ taskset -c 2 ./cpu_processor_test&
[1] 1615
ppid 1439 pid 1615

(2)查看确认绑定情况

$ taskset -p 1615
pid 1615's current affinity mask: 4

使用sched_setaffinity系统调用

sched_setaffinity可以将某个进程绑定到一个特定的CPU。

#define _GNU_SOURCE             /* See feature_test_macros(7) */
#include <sched.h>

/* 设置进程号为pid的进程运行在mask所设定的CPU上
 * 第二个参数cpusetsize是mask所指定的数的长度
 * 通常设定为sizeof(cpu_set_t)

 * 如果pid的值为0,则表示指定的是当前进程
 */
int sched_setaffinity(pid_t pid, size_t cpusetsize, cpu_set_t *mask);

int sched_getaffinity(pid_t pid, size_t cpusetsize, cpu_set_t *mask);/* 获得pid所指示的进程的CPU位掩码,并将该掩码返回到mask所指向的结构中 */

实例

#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>
#include<pthread.h>

#define MAX_THREAD_NUM 200  //1个CPU内的最多进程数

int cpu_cores_num = 0;  //cpu中核数
void *thread_test(void *arg)  //arg  传递线程标号(自己定义)
{
        cpu_set_t mask;  //CPU核的集合
        cpu_set_t get;   //获取在集合中的CPU
        int *cpu_index = (int *)arg;
        int i;

        printf("the thread is:%d\n",*cpu_index);  //显示是第几个线程
        CPU_ZERO(&mask);    //置空
        CPU_SET(*cpu_index,&mask);   //设置亲和力值
        if (sched_setaffinity(0, sizeof(mask), &mask) == -1)//设置线程CPU亲和力
        {
                printf("warning: could not set CPU affinity, continuing...\n");
        }

        CPU_ZERO(&get);
        if (sched_getaffinity(0, sizeof(get), &get) == -1)//获取线程CPU亲和力
        {
                printf("warning: cound not get thread affinity, continuing...\n");
        }
        for (int cpu_core_index = 0; cpu_core_index < cpu_cores_num; cpu_core_index++)
        {
                if (CPU_ISSET(cpu_core_index, &get))//判断线程与哪个CPU有亲和力
                {
                        printf("this thread %d is running processor : %d\n", cpu_core_index, cpu_core_index);
                }
        }

        return NULL;
}

int main(int argc, char *argv[])
{
        int tid[MAX_THREAD_NUM] = {0};
        int cpu_core_index = 0;
        pthread_t thread[MAX_THREAD_NUM];

        cpu_cores_num = sysconf(_SC_NPROCESSORS_CONF);  //获取核数
        if (cpu_cores_num > MAX_THREAD_NUM)
        {
                printf("cpu_cores_num of cores[%d] is bigger than MAX_THREAD_NUM[%d]!\n", cpu_cores_num, MAX_THREAD_NUM);
                return -1;
        }
        printf("system has %i processor(s). \n", cpu_cores_num);

        for(cpu_core_index = 0; cpu_core_index < cpu_cores_num;cpu_core_index++)
        {
                tid[cpu_core_index] = cpu_core_index;  //每个线程必须有个tid[i]
                pthread_create(&thread[cpu_core_index],NULL,thread_test,(void*)&tid[cpu_core_index]);
        }
        for(cpu_core_index = 0; cpu_core_index < cpu_cores_num; cpu_core_index++)
        {
                pthread_join(thread[cpu_core_index],NULL);//等待所有的线程结束,线程为死循环所以CTRL+C结束
        }
        return 0;
}

运行结果

$ gcc cpu_processor_test.c -o cpu_processor_test -pthread

$./cpu_processor_test
system has 6 processor(s).
the thread is:0
the thread is:2
the thread is:5
the thread is:3
this thread 5 is running processor : 5
this thread 2 is running processor : 2
this thread 3 is running processor : 3
the thread is:1
the thread is:4
this thread 4 is running processor : 4
this thread 0 is running processor : 0
this thread 1 is running processor : 1

绑定线程到cpu核上运行

绑定线程到cpu核上使用pthread_setaffinity_np函数,其原型定义如下:

#define _GNU_SOURCE             /* See feature_test_macros(7) */
#include <pthread.h>

int pthread_setaffinity_np(pthread_t thread, size_t cpusetsize, const cpu_set_t *cpuset);
int pthread_getaffinity_np(pthread_t thread, size_t cpusetsize, cpu_set_t *cpuset);

Compile and link with -pthread.

各参数的意义与sched_setaffinity相似。

实例

#define _GNU_SOURCE
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>

#define handle_error_en(en, msg) \
do { \
        errno = en; \
        perror(msg); \
        exit(EXIT_FAILURE); \
} while (0)

int main(int argc, char *argv[])
{
        int s, j;
        cpu_set_t cpuset;

        pthread_t thread = pthread_self();
        /* Set affinity mask to include CPUs 0 to 7 */

        CPU_ZERO(&cpuset);
        for (j = 0; j < 8; j++)
        {
                CPU_SET(j, &cpuset);
        }

        s = pthread_setaffinity_np(thread, sizeof(cpu_set_t), &cpuset);
        if (s != 0) handle_error_en(s, "pthread_setaffinity_np");

        /* Check the actual affinity mask assigned to the thread */
        s = pthread_getaffinity_np(thread, sizeof(cpu_set_t), &cpuset);
        if (s != 0) handle_error_en(s, "pthread_getaffinity_np");
        printf("Set returned by pthread_getaffinity_np() contained:\n");
        for (j = 0; j < CPU_SETSIZE; j++)
        {
                if (CPU_ISSET(j, &cpuset)) printf("    CPU %d\n", j);
        }
      
        exit(EXIT_SUCCESS);

        return 0;
}

运行结果

$  gcc cpu_processor_test.c -o cpu_processor_test -pthread
$ ./cpu_processor_test                                   
Set returned by pthread_getaffinity_np() contained:
    CPU 0
    CPU 1
    CPU 2
    CPU 3
    CPU 4
    CPU 5

总结

可以使用多种方法把进程/线程指定到特定的cpu核上运行。

在具体使用中,要根据使用场景和需求决定使用何种方式。
 

linux将进/线程绑定核心运行(cpu亲和性) 查看cpu核心数 cpu一般有多个物理核心,但在运行进程和线程时候,可以将其绑定或者指定到某一个或者多个核心上运行。我们在系统上有两种方法可以查看cpu核心数。 1.cat /proc/cpuinfo查看cpu的核心数以及信息,这里以树莓派3B为例: processor : 0 model name : ARMv7 Processor rev 4 (v7l) BogoMIPS : 38.40 Features : half thumb fastmult... 阅读详情

相关推荐

Linux C++程序下把进程/线程绑定到指定cpu核上运行

在大数据量的数据图像处理过程中,我们通常需要提升处理效率和性能,意识优化算法,而是充分利用服务器的硬件资源,如CPU和GPU。 平时应用程序在运行时都是由操作系统管理的。操作系统对应用进程进行调度,使其在不同的核上轮番运行。 对于普通的应用,操作系统的默认调度机制是没有问题的。但是,当某个进程需要较高的运行效率时,就有必要考虑将其绑定到单独...

程序猿老樊的博客 5979

使用taskset命令限定Linux下CPU逻辑核的使用对象及个数

Linux下的绑核命令——taskset 原文:https://time-track.cn/taskset-command.html 什么是绑核 所谓绑核,其实就是设定某个进程/线程与某个CPU核的亲和力(affinity)。设定以后,Linux调度器就会让这个进程/线程只在所绑定的核上面去运行。但并不是说该进程/线程就独占这个CPU的核,其他的进程/线程还是可以在这个核上面运行的。如果想要...

野心家-Andy的博客 6546

Xilinx Vivado vitis IDE launch Failed \ Web installer client Obsolete 怎么办

Xilinx vitis_IDE failed Web installer client Obsolete

weixin_44820962的博客 8646

Linux下cpu和绑核

CPU、核心隔离、绑核

wqfhenanxc的专栏 4411

潜流式人工湿地计算_复合人工湿地净化水产养殖污水技术

技术概论1. 定义与分类人工湿地是指用人工筑成水池或沟槽,底面铺设防渗漏隔水层,充填一定深度的基质层,种植水生植物,利用基质、植物、微生物的物理、化学、生物三重协同作用使污水得到净化的系统。当池塘养殖污水进入人工湿地时,其污染物被床体吸附、过滤、分解而达到水质净化作用。按照水体流动方式,人工湿地分为表面流人工湿地、水平潜流人工湿地、垂直潜流人工湿地以及由前面几种湿地混合搭配的组合式人工湿...

weixin_42365490的博客 4249

《AI应用架构师必学:企业AI能力地图构建的高级技巧》

企业AI能力地图,简单来说,是一种可视化工具,它展示了企业在AI领域所具备的各种能力及其相互关系。就如同城市地图展示城市的街道、建筑和设施一样,AI能力地图呈现了企业在数据处理、模型开发、算法应用等多个方面的能力布局。

AGI×大数据,开启智能时代的认知跃迁;解码AGI,赋能数据驱动的智能革命。 820

Linux上将进程、线程与CPU核绑定

Linux上将进程、线程与CPU核绑定

网络资源是无限的 4931

Ubuntu20.04安装Ceres库

ceres真难安装。

little_white138的博客 8382

linux指定cpu运行程序,进程/线程绑定到特定CPU核的linux实现(有代码有实例)

前言现在计算机上的CPU大多都是多核的,有4核甚至是8核的。但是一个计算机启动之后其进程数是远远多于CPU核数的,因为操作系统会给自动调度这些进程在CPU核上轮流运行。但是对于应用程序或者进程,其性能要求较高时,可能有必要绑定该进程到指定的CPU核来运行,避免调度带来的额外开销。我自己也是因为最近的项目上有需要进程运行在指定的CPU核上的要求,所以了解了一下这项技术,并且将过程和总结记录于此。CP...

weixin_34401008的博客 1146

【OpenBMC 系列】4.启动流程 使用qume模拟ast2600-evb

1.安装openbmc适配的qume 2.启动bmc 3.使用bmc web

AiFool的博客 4461

基于树莓派4B设计的厨房环境监测系统_368

本项目设计并实现了一种基于树莓派4B的厨房环境监测系统,提升厨房使用过程中的安全性与智能化水平。系统采用树莓派4B作为主控核心,集成DHT11温湿度传感器、MQ2烟雾传感器、火焰传感器、光敏传感器、水滴检测传感器等多种传感器,实现对厨房环境温湿度、烟雾、火焰、光照与溢水等参数的实时监测,并通过蜂鸣器进行本地报警。系统通过WIFI连接互联网,利用MQTT协议将环境数据上传至华为云物联网平台,实现远程可视化监控。

420

c++中cpu-绑核

在C++程序中进行CPU核心绑定(也称为CPU亲和性设置),指的是将程序的线程或进程绑定到特定的CPU核心上运行。这种做法可以带来一系列的好处,是实现提高cpu缓冲命中率,减少上下文切换开销重要解决方案。这是 Linux 系统上最常用的绑核方法。二、使用 taskset命令行工具(linux)在启动程序时通过taskset绑定核心。三、特别说明。

weixin_40468982的博客 868

智能手表竞品分析与市场调研报告

本报告旨在通过调研当前主流智能手表产品的功能特点、市场表现、用户反馈、定价策略等方面,辅助我司即将立项的Aurora Watch S1产品在功能定义、目标用户、定价区间、差异化竞争等方面做出科学决策。 调研范围包括国内外中端价位主流品牌(¥199~¥999),重点关注小米、华为、荣耀、Amazfit、Redmi、Haylou 等品牌的热销型号。

hoony123的博客 7万+

【linux】把进程/线程绑定到特定cpu核上运行

目的 某个进程需要较高的运行效率时,就有必要考虑将其绑定到单独的核上运行,以减小由于在不同的核上调度造成的开销。 把某个进程/线程绑定到特定的cpu核上后,该进程就会一直在此核上运行,不会再被操作系统调度到其他核上。但绑定的这个核还是可能会被调度运行其他应用程序的。 命令绑定 查看绑定情况 查看进程pid现在的绑核情况 taskset -p pid pid 2726's current affinity mask: 6 显示的十进制数字6--->转换为2进制是110,每个1对应一个cp

我的笔记本 2万+

电商行业分析爬虫:抓取行业数据,进行行业分析

电商行业数据分析对于市场研究、竞争分析和商业决策至关重要。通过爬取电商平台的数据,我们可以深入了解市场动态、消费者行为和商品销售情况。本文将介绍如何构建一个电商行业分析爬虫,抓取商品信息、销售数据和用户评价等,并进行数据分析。

u014481728的博客 1630

Statistics and Machine Learning Toolbox

Statistics and Machine Learning Toolbox(带书签),MATLAB统计学习工具

线程/进程和核绑定(CPU亲和性)

文章目录前言一、CPU亲和性1 前言2 为何要手动绑定线程/进程到CPU核3 多进程和多线程在多核CPU上运行:4 应用场景举例二、Linux的CPU亲和性特征1 软亲和性2 硬亲和性3 硬亲和性使用场景三、查看CPU的核1 使用指令2 使用sysconf四、Linux操作系统中修改CPU亲和性的方法1 taskset1.1 获取进程pid:`ps`1.2 查看进程当前运行在哪个cpu上1.3 指定进程运行在cpu1上1.4 如何确认绑定成功1.5 启动程序时绑定cpu2 Linux API2.1 绑定进程

Antrn 1万+

visio安装包

Microsoft Office Visio 是一款专业的制图软件。利用经过更新的形状、协作工具和数据链接图表,创建专业级图表以简化复杂的信息。

Linux绑定CPU运行指定进程(绑核)-taskset

Linux绑定CPU运行指定进程 前言 最近在arm上测试一些节点的性能,发现节点性能变化很大,尤其是当有其他高消耗的资源起来后,性能就会变得相当不稳定,因此怀疑是多个进程在争抢一个CPU的资源,从而导致该节点的性能变化过大。 如何查看Linux核数 # 总核数 = 物理CPU个数 X 每颗物理CPU的核数 # 总逻辑CPU数 = 物理CPU个数 X 每颗物理CPU的核数 X 超线程数 # 查...

此心光明,亦复何言~ 2万+

廖雪峰Python教程[完整版]

廖雪峰的python教程整理的,已经排好版了,而且还是完整的,适合小白

计算机控制技术及应用

《计算机控制技术及应用》通过总结作者的科研成果和吸收国内外的先进理论、方法和技术,以计算机控制系统的网络化、开放化、智能化和集成化发展趋势为主线索,主要介绍计算机控制系统的基本概念和计算机控制系统的典型形式,计算机控制系统的数学描述与基本分析方法,以及数字PID控制器、最少拍控制系统、达林算法、状态变量设计法等设计方法及其各种改进算法。重点突出计算机控制系统输入输出通道接口的设计方法和典型控制系统的设计案例与实现方法等。

linux下把进程/线程绑定到特定cpu核上运行

概述 现在大家使用的基本上都是多核cpu,一般是4核的。平时应用程序在运行时都是由操作系统管理的。操作系统对应用进程进行调度,使其在不同的核上轮番运行。 对于普通的应用,操作系统的默认调度机制是没有问题的。但是,当某个进程需要较高的运行效率时,就有必要考虑将其绑定到单独的核上运行,以减小由于在不同的核上调度造成的开销。 把某个进程/线程绑定到特定的cpu核上后,该进程就会一直在此核上运行,不...

guotianqing的博客 11万+

如何将进程线程与CPU核进行绑定

如何将进程、线程与CPU核进行绑定 CPU绑定指的是在多核CPU的系统中将进程或线程绑定到指定的CPU核上去执行。在Linux中,我们可以利用CPU affinity属性把进程绑定到一个或多个CPU核上。 CPU Affinity是进程的一个属性,这个属性指明了进程调度器能够把这个进程调度到哪些CPU上。该属性要求进程在某个指定的CPU上尽量长时间地运行而不被迁移到其他处理器。...

DeepDriving 4720

Linux:进程的CPU配置与线程的绑定操作

Linux下进程的CPU隔离配置和线程绑定,做了一个简单的学习了解。

HandsomeJacky的博客 4081

linux下把进程绑定到特定cpu核上运行

现在大家使用的基本上都是多核cpu,一般是4核的。平时应用程序在运行时都是由操作系统管理的。操作系统对应用进程进行调度,使其在不同的核上轮番运行。 对于普通的应用,操作系统的默认调度机制是没有问题的。但是,当某个进程需要较高的运行效率时,就有必要考虑将其绑定到单独的核上运行,以减小由于在不同的核上调度造成的开销。 把某个进程/线程绑定到特定的cpu核上后,该进程就会一直在此核上运行,不会再被操作系统调度到其他核上。但绑定的这个核上还是可能会被调度运行其他应用程序的。 操作系统对多核cpu的调度 目

Free雅轩的博客 2588

linux进程与线程的核绑定操作

linux进程与线程的核绑定操作

yyz916的博客 4678
上一篇: CMakeLists Guide笔记
下一篇: 【C语言】十进制,十六进制,浮点数转换成字符串,实现printf函数(串口打印)
IT笔记
博客等级 码龄13年 41粉丝 46原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值