精华内容
下载资源
问答
  • linux cpu绑定

    千次阅读 2016-10-22 15:10:33
    简要介绍自己在学习linuxcpu绑定的一些内容,部分内容总结于互联网

    一、说明

    运行环境:虚拟机 gentoo4.4.6 3核心cpu

              gcc 4.9.3

    参考资料:文中部分代码和内容参照以下网络资料,如有侵权,请及时联系。

             Linux CPU affinityhttp://blog.csdn.net/yfkiss/article/details/7464968

             top指令:http://developer.51cto.com/art/201509/492641.htm

                      http://www.cnblogs.com/yjf512/p/3383915.html

            Linux进程或线程绑定到CPU

                      http://www.linuxidc.com/Linux/2015-04/116867.htm

                      http://0987654321.blog.51cto.com/6934559/1409979

            unix环境高级编程》第11章:线程

    二、中断绑定cpu

     以网卡中断为例:对于网卡中断来说,有时会因为大量的网络中断导致cpu繁忙,可以通过将网卡中断绑定到特定的cpu,这样即使网络再繁忙,也不会使cpu响应其它请求变得太慢。

     

    图中说明网卡中断为19,其smp_affinity 0x07,注意,这个值是以16进制表示,换成二进制就是0111, 也就说明3cpu核心都可以相应网卡中断(虚拟机中设定了该系统使用3cpu),

       如果只让网卡中断绑定一个cpu,例如cpu0 ,  可以使用下面的方法:

         Echo ‘1’ > /proc/irq/19/smp_affinity

    具体细节可以参看内核源码文档: 内核源码:Documentation/IRQ-affinity

     

    三、进程(线程)运行中绑定cpu

    3.1单线程进程消耗cpu情况

    3.1.1指定cpu

    将某个正在运行,或是开始运行时就可以指定cpu

    taskset(需安装schedutils)  

    // 代码出出Linux CPU affinity: http://blog.csdn.net/yfkiss/article/details/7464968
    //test.c
    #include<stdio.h>
    void main(int argc, char** argv)
    {
        int i=0;
       for(i=0;i<100000000;i++)
          {
              if(i==10000)
       {
          i=0;
               printf("program is running!\n");
       }
          }
     
    }

    两种设置方法  

    taskset -c 0 ./test      test为程序名

    Tastset -cp 0 pid       pid为进程号

     

      图片中的数据看,虚拟机(程序运行在虚拟机中的linux系统中)中的cpu0确实

    最繁忙 ,但cpu1 cpu2 sys(内核态占用的cpu)仍然较高,并且从宿主机的cpu占用情况看,虚拟机中的3cpu感觉都快满了。这一结果与网友的一篇博客不符合:

     Linux CPU affinity  http://blog.csdn.net/yfkiss/article/details/7464968

     

    现在我们换一种程序的写法:

    //test.c
    #include<stdio.h>
    void main(int argc, char** argv)
    {
        int i=0;
       for(i=0;i<100000000;i++)
          {
              if(i==10000)
       {
          i=0;
              //printf("program is running!\n");将打印信息注注释掉,
       }
          }
     
    }


     

    我们再来看cpu占用情况:

     

     

     这个结果才是我们想要的,对吧。我猜想是不是taskset不能控制内核进程的占用cpu情况,对于有打印的那个test.c,会引起内核线程的调用,导致三个cpu都有较高的使用率。

       我以目前的知识做出猜测:Printf最终会产生80h中断,系统调用,就是内核态,所以在消耗的cpu中,usr,sys各占一部分,而内核态对cpu的占用,我们使用taskset是无法控制的。反之,没有printf的就没有sys消耗了,我们就能控制只占用一个cpuusr部分

       此外,我也做过小实验,用test去调用另外的进程(自己写的,会占用3个cpu的usr 100%),当我控制test只在一个cpu上运行时,所调用的能跑满3个cpu的进程,也就只在一个cpu上运行。

     

    3.1.2不指定cpu

     对与没有打印语句的test.c

    ./test  结果: 与指定cpu的情况一致,也是占用一个cpu 100 usr  0 sys

     

     对有打印语句的test.c

    ./test  结果: 与指定cpu的情况一致,也是占用一个cpu 75 usr  25 sys

    6.1usr  45sys   4usr  61 sys

     

    3.2多线程进程消耗cpu情况

    #include<stdio.h>
    #include<pthread.h>
     
    void thr_fn1(void *arg)
    {
    int j=0;
       for(j=0;j<100000000;j++)
          {
              if(j==10000)
       {
          j=0;
          printf("program is running %d!\n",j);
       }
          }
    }
     
    void thr_fn2(void *arg)
    {
    int k=0;
       for(k=0;k<100000000;k++)
          {
              if(k==10000)
       {
          k=0;
          printf("program is running %d!\n",k);
       }
          }
    }
     
    void main(int argc, char** argv)
    {
       int i=0;
       
       err=pthread_create(&ntid,NULL,thr_fn1,NULL);
       if(err!=0)
       {
       printf("cannot create thread");
       exit(1);
       }
     
       err=pthread_create(&ntid,NULL,thr_fn2,NULL);
       if(err!=0)
       {
       printf("cannot create thread");
       exit(1);
       }
       
       for(i=0;i<100000000;i++)
          {
              if(i==10000)
       {
          i=0;
          printf("program is running!\n");
       }
          }
     
    }

    3.2.1指定cpu

      不打印语句:如果指定cpu  ,则只有一个cpu满负载,其它两个cpu比较悠闲,且其它两个cpusys占用也很低

       打印语句: 如果指定cpu,  一个全部满载,另外两个的usr会比较空闲,但是sys占用率仍然高。

     

    3.2.2不指定cpu

      不打印语句:如果不指定cpu,则三个cpu usr都会满负载。

      打印语句:如果不指定cpu,则三个都会满载,与单线程不同的是,每个cpu核的sys占用都较高

     

    Ps: 具体的占用情况需呀读者自己去尝试,分析

       要让top输出某个特定进程<pid>并检查该进程内运行的线程状况:

    $ top -H -p <pid>

      

    四、在函数中显示的对线程绑定cpu

    //代码出处: http://0987654321.blog.51cto.com/6934559/1409979
    void *MyfunWithMultiThread(void *arg)
       {
           cpu_set_t mask;
           cpu_set_t get;
           int i = 0;
           int num = 0;
           int cpuID = *(int *)arg;
           CPU_ZERO(&mask);
           CPU_SET(2, &mask);
           if (pthread_setaffinity_np(pthread_self(), sizeof(mask), &mask) < 0) {  //对线程的cpu addinity值进行调整,绑定到cpu2
               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");
           }
           num = sysconf(_SC_NPROCESSORS_CONF);
           for (i = 0; i < num; i++) {
               if (CPU_ISSET(i, &get)) {
                   printf("thread %d is running in processor %d\n", (int)pthread_self(), i);
                   printf("Original setting is in processor  %d\n\n", cpuID);
               }
           }
           sleep(10);
       }
    

     

    对于进程的绑定:

     int sched_setaffinity(pid_t pid, size_t cpusetsize, const cpu_set_t *mask);

     int sched_getaffinity(pid_t pid, size_t cpusetsize, cpu_set_t *mask);

     

    展开全文
  • Linux CPU性能测试

    2017-11-05 22:03:00
    Linux CPU性能测试: 计算圆周率,时间越短性能越好 # time echo "scale=5000;4*a(1)"|bc -l -q 本文转自linux博客51CTO博客,原文链接http://blog.51cto.com/yangzhiming/1980678如需转载请自行联系原作者 ...

    Linux CPU性能测试:


    计算圆周率,时间越短性能越好


    # time echo "scale=5000;4*a(1)"|bc -l -q

    本文转自linux博客51CTO博客,原文链接http://blog.51cto.com/yangzhiming/1980678如需转载请自行联系原作者


    yangzhimingg

    展开全文
  • Linux Cpu占用高调试方法

    千次阅读 2016-06-01 08:56:42
    Linux Cpu占用高调试方法

    1.首先是用top命令确定 有问题的pid

    然后用top -H -p pid命令查看进程内各个线程占用的CPU百分比
    >top -H -p 14094

    or

    或者使用  > ps H -e -o pid,tid,pcpu,cmd --sort=pcpu |grep xxx


    2.接下来,我们用gdb来attach目标进程

    gdb
    gdb>attach 2907

    在gdb中,列出线程状态:

    (gdb) info threads   
    9 Thread 47056948181264 (LWP 11066)  0x00002acc4a3dec91 in nanosleep () from /lib/libc.so.6   
    8 Thread 47056956573968 (LWP 11067)  0x00002acc4a406fc2 in select () from /lib/libc.so.6   
    7 Thread 47056964966672 (LWP 11068)  0x00002acc4a3dec91 in nanosleep () from /lib/libc.so.6  
     6 Thread 47056973359376 (LWP 11069)  0x00002acc4a3dec91 in nanosleep () from /lib/libc.so.6   
    5 Thread 47056981752080 (LWP 11070)  0x00002acc4a3dec91 in nanosleep () from /lib/libc.so.6   
    4 Thread 47056990144784 (LWP 11071)  0x00002acc4a40e63c in recvfrom () from /lib/libc.so.6   
    3 Thread 47057194060048 (LWP 11072)  0x00002acc4a406fc2 in select () from /lib/libc.so.6   
    2 Thread 47057226893584 (LWP 11073)  CSendFile::SendFile (this=0x2acc5d4aff40, pathname=@0x2acc5d4afee0    at ../src/csendfile.cpp:101   
    1 Thread 47056939784832 (LWP 11065)  0x00002acc4a3dec91 in nanosleep () from /lib/libc.so.6 (gdb) 


    gdb已经列出了各线程正在执行的函数,我们需要更多信息,记住11073对应的行首标号,这是gdb为线程分配的id,这里为2,然后执行切换:

    (gdb) thread 2 
    [Switching to thread 2 (Thread 47057226893584 (LWP 11073))]#0  CSendFile::SendFile (this=0x2acc5d4aff40, pathname=@0x2acc5d4afee0    at ../src/csendfile.cpp:101 101             while(1
    (gdb) 

    bt一下:

    (gdb) bt 
    #0  CSendFile::SendFile (this=0x2acc5d4aff40, pathname=@0x2acc5d4afee0) at ../src/csendfile.cpp:101 
    #1  0x000000000040592e in CIcdn::TaskThread (pParam=0x7fff617eafe0) at ../src/cicdn.cpp:128 
    #2  0x00002acc4a90b73a in start_thread () from /lib/libpthread.so.0 
    #3  0x00002acc4a40d6dd in clone () from /lib/libc.so.6 
    #4  0x0000000000000000 in ?? ()


    来看一下101行的代码:

    (gdb) l 
    96      } 
    97 
    98      int CSendFile::SendFile(const string& pathname) 
    99      {
    100             int n;
    101             while(1)
    102             {
    103                     n++;
    104             }
    105             //read file and send 

    现在我们定位到了出问题的代码位置,这里的循环只用来演示的。 
    最后别忘了detach()

    调试完指定进程后,可以运行detach命令来让GDB释放该进程,该进程得以继续运行。当回车时,detach不会重复。当执行完detach后,进程和GDB不再相关,GDB可以attach其他进程。


    2. 使用 pstack

    1.安装pstack

    yum install pstack

    使用方式:

    >pstack pid 根据pid找出有问题的线程

    >strace -p pid //这个线程所有系统调用


    展开全文
  • 在“Linux CPU core的电源管理(1)_概述”中,我们多次提到SMP、CPU core等概念,虽然硬着头皮写下去了,但是蜗蜗对这些概念总有些似懂非懂的感觉。它们和CPU的进化过程息息相关,最终会体现在CPU topology(拓扑结构...

    1. 前言

    在“Linux CPU core的电源管理(1)_概述”中,我们多次提到SMP、CPU core等概念,虽然硬着头皮写下去了,但是蜗蜗对这些概念总有些似懂非懂的感觉。它们和CPU的进化过程息息相关,最终会体现在CPU topology(拓扑结构)上。因此本文将以CPU topology为主线,介绍CPU有关(主要以ARM CPU为例)的知识。

    另外,CPU topology除了描述CPU的组成之外,其主要功能,是向kernel调度器提供必要的信息,以便让它合理地分配任务,最终达到性能和功耗之间的平衡。这也是我将“cpu topology”归类为“电源管理子系统”的原因。

    2. CPU topology

    2.1 一个例子

    开始之前,先看一个例子,下面是蜗蜗所使用的编译服务器的CPU architecture信息:

    [xxx@cs ~]# lscpu

    Architecture:          x86_64 
    CPU op-mode(s):        32-bit, 64-bit 
    Byte Order:            Little Endian 
    CPU(s):                24 
    On-line CPU(s) list:   0-23 
    Thread(s) per core:    2 
    Core(s) per socket:    6 
    Socket(s):             2 
    NUMA node(s):          2 
    Vendor ID:             GenuineIntel 
    CPU family:            6 
    Model:                 62 
    Stepping:              4 
    CPU MHz:               2100.118 
    BogoMIPS:              4199.92 
    Virtualization:        VT-x 
    L1d cache:             32K 
    L1i cache:             32K 
    L2 cache:              256K 
    L3 cache:              15360K 
    NUMA node0 CPU(s):     0,2,4,6,8,10,12,14,16,18,20,22 
    NUMA node1 CPU(s):     1,3,5,7,9,11,13,15,17,19,21,23

    注意其中蓝色字体部分,该服务器有24个CPU,组成方式是:2个sockets,每个socket有6个core,每个core有2个thread。另外,这些CPU可以划分为2个NUMA node。晕吧,知道我在说什么吗?不知道就对了,让我做进一步的解释。

    2.2 单核和多核

    在英文里面,单核(single-core)和多核(multi-core)多称作uniprocessor和multiprocessor,这里先对这些概念做一个说明:

    这里所说的core(或processor),是一个泛指,是从使用者(或消费者)的角度看计算机系统。因此,core,或者processor,或者处理器(CPU),都是逻辑概念,指的是一个可以独立运算、处理的核心。

    而这个核心,可以以任何形式存在,例如:单独的一个chip(如通常意义上的单核处理器);一个chip上集成多个核心(如SMP,symmetric multiprocessing);一个核心上实现多个hardware context,以支持多线程(如SMT,Simultaneous multithreading);等等。这是从硬件实现的角度看的。

    最后,从操作系统进程调度的角度,又会统一看待这些不同硬件实现的核心,例如2.1中所提及的CPU(24个CPUs),因为它们都有一个共同的特点:执行进程(或线程)。

    在传统的单核时代,提升处理器性能的唯一手段就是提高频率。但受限于物理工艺,频率不能无限提高(例如散热问题等)。对多核处理器来说,可利用的空间增多,散热问题就比较容易解决。这就是multiprocessor诞生的背景。

    另外,现实中的多任务需求,也是multiprocessor得以发展的基础,例如智能手机中,可以使用一个processor处理通信协议,另一个processor处理UI交互、多媒体等,这可以让用户在享受“智能”的同时,确保不miss基础的通信需求。

    2.3 SMP、SMT、NUMA等概念

    比较常见的multiprocessor实现,是将多个功能完全相同的processor集成在一起(可以在一个chip上,也可以在多个chip),它们共享总线、memory等系统资源,这称作SMP(Symmetric Multi-Processing),如下面图片中的CORE000、CORE001…。从Linux kernel的角度,通常称这些功能独立的process为Core。

    另外,基于制程、扩充性等考虑,芯片厂商会把多个Core封装在一个chip上,这也称作Socket。Socket的概念在X86架构上使用尤其多,可以理解为插槽。假设一个插槽有两个Core,那么我在主板上插2个插槽,就是4核系统,插4个插槽,就是8核系统。不过Socket在ARM体系结构上使用却比较少,后面我们会介绍另外一个类似概念(Cluster)。

    大多数操作系统(如Windows、Linux),有进程和线程的概念。进程是程序的运行实例,可以包括很多线程。线程是调度的最小单位。因此有些处理器(Core),可以通过复制硬件寄存器状态等手段,同时执行多个线程,这叫做SMT(Simultanous Multi-Thread)

    下面图片以及2.1中的例子,反映了多核系统的简单topology。

    mc_support

    前面讲过,Core之间会共享总线、memory等资源。如果Core的数量较少,则没什么问题,但随着Core的增多,对总线以及memory带宽的需求就会显著增大,最终总线和memory会成为系统性能的瓶颈。解决方法是:

    某些Core之间,独享总线和memory,称作Node。正常情况下,Core只访问Node内的memory,因此可以减轻对总线和memory的带宽需求。但是,有些场景下,Core会不可避免的访问其它Node的memory,这会造成很大的访问延迟。

    因此,这种技术称作NUMA(Non-uniform Memory Access),以内存访问的不一致性为代价,减轻对总线和memory的带宽需求。这种结构对进程调度算法的要求较高,尽量减少跨Node的内存访问次数,以提升系统性能。

    2.4 ARM HMP(Heterogeneous Multi-Processing)

    前面提到的拓扑结构,大多存在于X86架构的PC、服务器上,唯一目标就是提升CPU的处理性能(不在乎功耗)。但在移动市场(大多是ARM的天下),事情就复杂多了。

    随着智能设备的普及,用户对移动设备的性能需求越来越高,相应的就更多有的power消耗,这对设备的电源管理以及散热处理提出了更高的要求。与此同时,电池技术却没有随着CPU拓扑结构的进化而进化,这就导致上述的拓扑结构不太适合对功耗特别敏感的移动设备,这就是ARM的HMP技术提出的背景。

    Heterogeneous的中文意思是“异形的、多种多样的”,从字面意思理解,就是其内部的多个Core有着不同的实现(相对于SMP)。它的产生基于下面两个事实:

    1)在处理同等事务的情况下,处理器的性能越高,其能量损耗就越大。这是由物理工艺决定的。

    2)以智能手机为例,必须由高性能CPU来完成的事务,在所有事物里的比重是非常小的,如大型游戏、高清视频播放等。甚至很多用户从来都没有用过。

    因此,ARM提出类似下面架构的HMP架构,在一个chip中,封装两类ARM Core,一类为高性能Core(如Cortex-A15,也称作big core),一类为低性能Core(如Cortex-A7,也称作little core),因此HMP也称作big·little架构。其中:

    big core的处理性能高,但功耗较大;

    little core的功耗低;

    因此软件(如OS的调度器)可以根据需求,将任务分配到big core或者little上,以满足性能和功耗的平衡。

    HMP

    在ARM的术语中,所有big core或者所有little core组合,称作cluster(可以类比为2.3中所描述的Socket,但意义完全不同),因此在多数的ARM处理器中(不排除后续ARM服务器又不同实现),CPU topology如下:

    Cluster-->Core-->Threads

    在软件模型上,基本和2.3中描述的“Socket—>Core-->Threads”拓扑兼容。

    3. Linux kernel CPU topology driver

    弄明白CPU topology的物理基础之后,再来看Linux kernel的CPU topology driver就简单多了,其软件层次如下:

    ---------------------------------------------     --------------------------------------------  
    |       CPU topology driver        |     |      Task Scheduler etc.       | 
    ---------------------------------------------     -------------------------------------------

    ---------------------------------------------------------------------------------------------- 
    |                             Kernel general CPU topology                      | 
    ----------------------------------------------------------------------------------------------

    ---------------------------------------------------------------------------------------------- 
    |                            arch-dependent CPU topology                     | 
    ---------------------------------------------------------------------------------------------- 

    Kernel general CPU topology位于"include/linux/topology.h”中,定义了获取系统CPU topology信息的标准接口。底层的arch-dependent CPU topology会根据平台的特性,实现kernel定义的那些接口。

    CPU topology信息有两个重要的使用场景:一是向用户提供当前的CPU信息(2.1中的lscpu),这是由CPU topology driver实现的;二是向调度器提供CPU core的信息,以便合理的调度任务。

    下面将重点介绍Kernel general CPU topology、arch-dependent CPU topology和CPU topology driver,其中arch-dependent CPU topology会以ARM64平台为例。至于如何知道任务调度,则比较复杂,会放到其它文章中介绍。

    3.1 Kernel general CPU topology

    Kernel general CPU topology主要以“#ifndef ... #define”类型的宏定义的形式提供API,其目的是:底层的arch-dependent CPU topology可以重新定义这些宏,只要底层有定义,则优先使用底层的,否则就使用Kernel general CPU topology中的默认API,主要包括:

       1: /* include/linux/topology.h */
       2:  
       3: #ifndef topology_physical_package_id
       4: #define topology_physical_package_id(cpu)       ((void)(cpu), -1)
       5: #endif
       6: #ifndef topology_core_id
       7: #define topology_core_id(cpu)                   ((void)(cpu), 0)
       8: #endif
       9: #ifndef topology_thread_cpumask
      10: #define topology_thread_cpumask(cpu)            cpumask_of(cpu)
      11: #endif
      12: #ifndef topology_core_cpumask
      13: #define topology_core_cpumask(cpu)              cpumask_of(cpu)
      14: #endif
      15:  
      16: #ifdef CONFIG_SCHED_SMT
      17: static inline const struct cpumask *cpu_smt_mask(int cpu)
      18: {
      19:         return topology_thread_cpumask(cpu);
      20: }
      21: #endif
      22:  
      23: static inline const struct cpumask *cpu_cpu_mask(int cpu)
      24: {
      25:         return cpumask_of_node(cpu_to_node(cpu));
      26: }

    topology_physical_package_id用于获取某个CPU的package ID,即第2章所描述的socket或者cluster,具体意义依赖于具体平台的实现;

    topology_core_id用于或者某个CPU的core ID。即第二章所描述的core,具体意义依赖于具体的平台实现;

    topology_thread_cpumask,获取和该CPU属于同一个core的所有CPU,通俗的讲,就是姐妹Thread;

    topology_core_cpumask,获取和该CPU属于同一个packet(socket)的所有CPU;

    cpu_cpu_mask,获取该CPU属于同一个Node的所有CPU;

    cpu_smt_mask,用于SMT调度(CONFIG_SCHED_SMT)的一个封装,意义同topology_thread_cpumask。

    另外,"include/linux/topology.h”提供一个NUMA有关的API,由于当前ARM使用NUMA技术的可能性不大,我们暂不过多涉及。

    3.2 arch-dependent CPU topology

    对ARM64而言,arch-dependent CPU topology位于“arch/arm64/include/asm/topology.h”和“arch/arm64/kernel/topology.c”中,主要负责ARM64平台相关的topology转换,包括:

    1)定义一个数据结构,以及基于该数据结构的变量,用于存储系统的CPU topology

       1: /* arch/arm64/include/asm/topology.h */
       2:  
       3: struct cpu_topology {
       4:         int thread_id;
       5:         int core_id;
       6:         int cluster_id;
       7:         cpumask_t thread_sibling;
       8:         cpumask_t core_sibling;
       9: };
      10:  
      11: extern struct cpu_topology cpu_topology[NR_CPUS];

    cluster_id、core_id、thead_id分别对应2.3、2.4章节所描述的拓扑结构的三个层次,其中由于ARM架构的特殊性,以cluster代替了socket;

    thread_sibling和core_sibling为cpumask_t类型的变量,保存了和该CPU位于相同级别(同一个core和同一个cluster)的所有姐妹CPU;

    系统中每个CPU(个数由NR_CPUS指定,是从OS的角度看的),都有一个struct cpu_topology变量,用于描述该CPU在整个topology中的地位。这些变量以数组的形式(cpu_topology)维护。

    2)重定义CPU topology有关的宏定义

       1: /* arch/arm64/include/asm/topology.h */
       2:  
       3: #define topology_physical_package_id(cpu)       (cpu_topology[cpu].cluster_id)
       4: #define topology_core_id(cpu)           (cpu_topology[cpu].core_id)
       5: #define topology_core_cpumask(cpu)      (&cpu_topology[cpu].core_sibling)
       6: #define topology_thread_cpumask(cpu)    (&cpu_topology[cpu].thread_sibling)

    实现比较简单,从该CPU对应的struct cpu_topology变量中取出指定的字段即可。

    3)提供初始化并构建CPU topology的方法,以便在系统启动时调用

       1: /* arch/arm64/include/asm/topology.h */
       2:  
       3: void init_cpu_topology(void);
       4: void store_cpu_topology(unsigned int cpuid);

    init_cpu_topology的调用路径是:kernel_init-->smp_prepare_cpus-->init_cpu_topology,主要完成如下任务:

    初始化所有可能的CPU的struct cpu_topology变量;

    尝试从DTS中解析CPU topolog配置,配置的格式如下:

    cpus { 
            cpu-map {  
                    cluster0 { 
                            core0 { 
                                    thread0 { 
                                            cpu = <&big0>; 
                                    }; 
                                    thread1 { 
                                            cpu = <&big1>; 
                                    }; 
                            }; 
                            core1 { 
                                    … 
                            } 
                            … 
                    }; 
                   … 
            };

            big0: cpu@0 { 
                    device_type = "cpu"; 
                    compatible = "arm,cortex-a15"; 
                    reg = <0x0>; 
            }; 
            … 
    };

    具体可参考“Documentation/devicetree/bindings/arm/topology.txt”中的描述。

    store_cpu_topology的调用路径是:kernel_init-->smp_prepare_cpus-->store_cpu_topology,在没有从DTS中成功获取CPU topology的情况下,从ARM64的MPIDR寄存器中读取topology信息,具体可参考相应的代码,不再详细描述。

    3.3 CPU topology driver

    CPU topology driver位于“drivers\base\topology.c”中,基于“include/linux/topology.h”所提供的API,以sysfs的形式,向用户空间提供获取CPU topology信息的接口,lscpu应用,就是基于该接口实现的。

    具体的实现比较简单,sysfs的格式可参考“Documentation\cputopology.txt”,这里不再详细说明。

     

    原创文章,转发请注明出处。蜗窝科技www.wowotech.net

    展开全文
  • 由“Linux CPU core的电源管理(1)_概述”的描述可知,kernel cpu control位于“.\kernel\cpu.c”中,是一个承上启下的模块,负责屏蔽arch-dependent的实现细节,向上层软件提供控制CPU core的统一API(主要包括cpu...
  • 初探Linux CPU动态调频与实测

    千次阅读 2018-02-11 00:04:33
    本文主要涉及Linux CPUFreq子系统是什么,为什么需要,怎么用。并解决在实际测试中遇到的三个问题。
  • Linux cpufreq 机制

    千次阅读 2011-02-19 23:40:00
    Linux cpufreq 机制了解 Cpufreq 的由来 随着 energy efficient computing 和 performance per watt 等概念的推广以及高级配置与电源接口ACPI(Advanced Configuration and Power Interface)...
  • linux cpu查看信息

    千次阅读 2018-11-19 15:05:28
    最近在研究linux系统负载的时候,接触到一些关于CPU信息查看的知识,和大家分享一下。通过对/proc/cpuinfo文件中的参数的分析,也学到了不少东西。 在linux操作系统中,CPU的信息在启动的过程中被装载到虚拟目录/...
  • Linux CPU超频设置

    千次阅读 2020-08-07 09:37:52
    查看当前cpu运行频率: cat /proc/cpuinfo | grep -i “cpu mhz” 开始设置: cpupower -c all frequency-set -g performance 或者 cpupower frequency-set -g performance 再次查看当前cpu运行频率,既最大频率运行...
  • linux cpu 频率

    千次阅读 2017-12-12 10:40:00
    安装完,执行命令查看cpufreq-info 可以看到,rk3399的大小核,最大频率不一样, 大核A72 最大频率是1.8GHz 可以看到可以选择的频率和调节器 available frequency steps: 408 MHz, 600 MHz, 816 MHz, 1.01 GHz, ...
  • Linux cpufreq 简介

    千次阅读 2019-01-23 16:05:15
    CPU变频即改变CPU运行时的频率,CPU在不同的频率下运行时所需的电压不同,频率越高,所需的电压也随之升高,因此在移动设备领域,为了节省功耗,在系统suspend或者load较小时,让CPU运行在较低的频点,可以减少CPU的...
  • Linux CPU affinity

    千次阅读 2013-01-25 20:25:02
     linux中将某个进程或者线程绑定到特定的一个或者多个cpu上执行。   二.为什么需要CPU affinity  cache性能的提升,多个进程不断交替地在某个cpu上执行,导致缓存无效。  多线程程序运行于某个cpu,每...
  • linux cpu、内存、IO、网络的测试工具

    千次阅读 2017-08-15 17:49:54
    一、linux cpu、内存、IO、网络的测试工具cpu测试工具1、Super Pi for linuxSuper PI是利用CPU的浮点运算能力来计算出π(圆周率),所以目前普遍被用户用做测试系统稳定性和测试CPU计算完后特定位数圆周率所需的...
  • linux CPU使用率过高或负载过高的处理思路1、查看系统CPU负载及使用率的命令为:top vmstat top 命令:查看进程级别的cpu使用情况。 vmstat 命令:查看系统级别的cpu使用情况。 下面通过具体的图例来分析: 1.1 ...
  • Linux CPU调度策略

    千次阅读 2020-03-07 12:15:34
    所有的任务只占用cpu资源 任务的运行时间是已知的 这里的大部分假设都是不切合实际的,但是这个假设帮助我们更好的去理解和描述调度器。 我们定义周转时间为完成时间减去任务到达时间。 Tturnaround = ...
  • Linux CPU mask含义

    千次阅读 2017-08-14 10:05:33
    CPU mask 信息  解释 cpu_possible_mask 系统内可以setup的CPU位图 cpu_online_mask 系统内已经setup的CPU中,正在使用的CPU位图 cpu_present_mask 系统内已经setup的CPU位图 cpu_active_mask 系统内处于可...
  • linux cpu相关信息

    千次阅读 2018-04-20 10:35:12
    通过/proc/cpuinfo查看cpu信息 查看cpu信息 [root@localhost ~]# cat /proc/cpuinfo processor : 0 vendor_id : GenuineIntel cpu family : 6 model : 79 model name : Intel(R) Xeon(R) CPU E5-2620 v4 @ 2.1.....
  • linux cpu占用100%排查

    千次阅读 2019-05-30 00:51:59
    某服务器上部署了若干tomcat实例,即若干垂直切分的Java站点服务,以及若干Java微服务,突然收到运维的CPU异常告警。 问:如何定位是哪个服务进程导致CPU过载,哪个线程导致CPU过载,哪段代码导致CPU过载? 步骤一...
  • @[TOC]Grafana 监控Linux CPU, Memoy, disk等资源) 下载安装包 wget&amp;amp;amp;nbsp;https://dl.grafana.com/oss/release/grafana-5.4.2.linux-amd64.tar.gz&amp;amp;amp;nbsp; tar&amp;amp;amp;nbsp;...
  • linux cpu性能测试

    千次阅读 2017-12-19 20:27:50
    sysbench --test=cpu --cpu-max-prime=20000000 run --num-threads=4   mpstat -P ALL 1 1000000
  • linux cpu开启性能模式

    千次阅读 2020-06-08 09:22:00
    今天我们的一台数据库服务器,业务研发反馈tp999会不时的彪高,我们查询了各种指标,发现网络重传比较高,同事cpu的load比较高,但是统一宿主机上其他的docker没有重传,因此不是网卡的问题,通过dmesg,发现有cpu...
  • 查看cpu当前运行频率 cat /proc/cpuinfo | grep "cpu MHz" # lscpu 查看温度 apt install lm-sensors -y # sensors k10temp-pci-00c3 Adapter: PCI adapter ...如何在Ubuntu Linux中监控CPU和GPU温.
  • Linux CPU频率控制

    万次阅读 2016-03-27 17:59:00
    Linux 内部共有五种对频率的管理策略 userspace , conservative , ondemand , powersave 和 performance。 l performance : CPU 会固定工作在其支持的最高运行频率上; l powersave : CPU 会固定工作在...
  • # 总核数 = 物理CPU个数 X 每颗物理CPU的核数 # 总逻辑CPU数 = 物理CPU个数 X 每颗物理CPU的核数 X 超线程数 # 查看物理CPU个数 cat /proc/cpuinfo| grep "physical id"| sort| uniq| wc -l # 查看每个物理CPU中...
  • CPU 负载和 CPU 使用率 这两个从一定程度上都可以反映一台机器的繁忙程度。 CPU 使用率反映的是当前 CPU 的繁忙程度,忽高忽低的原因在于占用 CPU 处理时间的进程可能处于 IO 等待状态但却还未释放进入wait。 ...
  • linux cpu核心数查看

    千次阅读 2019-06-24 15:48:07
    # 查看物理CPU个数 cat /proc/cpuinfo| grep "physical id"| sort| uniq| wc -l # 查看每个物理CPU中core的个数(即核数) cat /proc/cpuinfo| grep "cpu cores"| uniq # 查看逻辑CPU的个数(超线程) cat /proc/...
  • linux cpu占用率分析

    千次阅读 2017-02-27 11:51:24
    http://blog.leanote.com/post/github-yihengliucc/linux-cpu%E5%8D%A0%E7%94%A8%E7%8E%87%E5%88%86%E6%9E%90 使用top命令查看可能会有进程占用率非常高,这个数值是进程内各个线程占用cpu的累加值。 ...
  • 可以用下面的命令将 cpu 占用率高的线程找出来: ps H -eo user,pid,ppid,tid,time,%cpu,cmd --sort=%cpu这个命令首先指定参数'H',显示线程相关的信息,格式输出中包含:user,pid,ppid,tid,time,%cpu,cmd,然后再用%...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 78,773
精华内容 31,509
关键字:

linuxcpu

linux 订阅