精华内容
下载资源
问答
  • 在深度学习模型训练过程中,在服务器端或者本地pc端,输入nvidia-smi来观察显卡的GPU内存占用率(Memory-Usage),显卡的GPU利用率(GPU-util),然后采用top来查看CPU的线程数(PID数)和利用率(%CPU)。...

            在深度学习模型训练过程中,在服务器端或者本地pc端,输入nvidia-smi来观察显卡的GPU内存占用率Memory-Usage),显卡的GPU利用率GPU-util),然后采用top来查看CPU的线程数(PID数)和利用率(%CPU)。往往会发现很多问题,比如,GPU内存占用率低,显卡利用率低,CPU百分比低等等。接下来仔细分析这些问题和处理办法。

    (ps:对于如何在Intel CPU,ARM架构CPU,以及Jetson TensorRT上部署深度学习模型,以及部署遇到的速度问题,该如何解决。请查看我的另外一篇文章。如何定制化编译Pytorch,TensorFlow,使得CNN模型在CPU,GPU,ARM架构和X86架构,都能快速运行,需要对每一个平台,有针对性的调整。如何做到最大化加速深度学习在不同平台部署性能。请看我的这篇文章。)

    深度学习模型部署性能分析,Intel和ARM CPU上CNN计算速度差距分析。

    1. GPU内存占用率问题

            这往往是由于模型的大小以及batch size的大小,来影响这个指标。当你发下你的GPU占用率很小的时候,比如40%,70%,等等。此时,如果你的网络结构已经固定,此时只需要改变batch size的大小,就可以尽量利用完整个GPU的内存。GPU的内存占用率主要是模型的大小,包括网络的宽度,深度,参数量,中间每一层的缓存,都会在内存中开辟空间来进行保存,所以模型本身会占用很大一部分内存。其次是batch size的大小,也会占用影响内存占用率。batch size设置为128,与设置为256相比,内存占用率是接近于2倍关系。当你batch  size设置为128,占用率为40%的话,设置为256时,此时模型的占用率约等于80%,偏差不大。所以在模型结构固定的情况下,尽量将batch size设置大,充分利用GPU的内存。(GPU会很快的算完你给进去的数据,主要瓶颈在CPU的数据吞吐量上面。)

    2. GPU利用率问题

            这个是Volatile GPU-Util表示,当没有设置好CPU的线程数时,这个参数是在反复的跳动的,0%,20%,70%,95%,0%。这样停息1-2 秒然后又重复起来。其实是GPU在等待数据从CPU传输过来,当从总线传输到GPU之后,GPU逐渐起计算来,利用率会突然升高,但是GPU的算力很强大,0.5秒就基本能处理完数据,所以利用率接下来又会降下去,等待下一个batch的传入。因此,这个GPU利用率瓶颈在内存带宽和内存介质上以及CPU的性能上面。最好当然就是换更好的四代或者更强大的内存条,配合更好的CPU。

            另外的一个方法是,在PyTorch这个框架里面,数据加载Dataloader上做更改和优化,包括num_workers(线程数),pin_memory,会提升速度。解决好数据传输的带宽瓶颈和GPU的运算效率低的问题。在TensorFlow下面,也有这个加载数据的设置。

    torch.utils.data.DataLoader(image_datasets[x],
                                batch_size=batch_size, 
                                shuffle=True,
                                num_workers=8,
                                pin_memory=True)

            为了提高利用率,首先要将num_workers(线程数)设置得体,4,8,16是几个常选的几个参数。本人测试过,将num_workers设置的非常大,例如,24,32,等,其效率反而降低,因为模型需要将数据平均分配到几个子线程去进行预处理,分发等数据操作,设高了反而影响效率。当然,线程数设置为1,是单个CPU来进行数据的预处理和传输给GPU,效率也会低。其次,当你的服务器或者电脑的内存较大,性能较好的时候,建议打开pin_memory打开,就省掉了将数据从CPU传入到缓存RAM里面,再给传输到GPU上;为True时是直接映射到GPU的相关内存块上,省掉了一点数据传输时间。

    3. CPU的利用率问题

            很多人在模型训练过程中,不只是关注GPU的各种性能参数,往往还需要查看CPU处理的怎么样,利用的好不好。这一点至关重要。但是对于CPU,不能一味追求超高的占用率。如图所示,对于14339这个程序来说,其CPU占用率为2349%(我的服务器是32核的,所以最高为3200%)。这表明用了24核CPU来加载数据和做预处理和后处理等。其实主要的CPU花在加载传输数据上。此时,来测量数据加载的时间发现,即使CPU利用率如此之高,其实际数据加载时间是设置恰当的DataLoader的20倍以上,也就是说这种方法来加载数据慢20倍。当DataLoader的num_workers=0时,或者不设置这个参数,会出现这个情况。

    CPU利用率查看结果
    CPU利用率查看结果

            下图中可以看出,加载数据的实际是12.8s,模型GPU运算时间是0.16s,loss反传和更新时间是0.48s。此时,即使CPU为2349%,但模型的训练速度还是非常慢,而且,GPU大部分是时间是空闲等待状态。

    num_workers=0,模型每个阶段运行时间统计

            当我将num_workers=1时,出现的时间统计如下,load data time为6.3,数据加载效率提升1倍。且此时的CPU利用率为170%,用的CPU并不多,性能提升1倍。

    num_workers=1时,模型每个阶段运行时间统计

            此时,查看GPU的性能状态(我的模型是放在1,2,3号卡上训练),发现,虽然GPU(1,2,3)的内存利用率很高,基本上为98%,但是利用率为0%左右。表面此时网络在等待从CPU传输数据到GPU,此时CPU疯狂加载数据,而GPU处于空闲状态

    1,2,3号GPU的内存占用率和计算效率截图

            由此可见,CPU的利用率不一定最大才最好。

            对于这个问题,解决办法是,增加DataLoader这个num_wokers的个数,主要是增加子线程的个数,来分担主线程的数据处理压力,多线程协同处理数据和传输数据,不用放在一个线程里负责所有的预处理和传输任务。

            我将num_workers=8,16都能取得不错的效果。此时用top查看CPU和线程数,如果我设置为num_workers=8,线程数有了8个连续开辟的线程PID,且大家的占用率都在100%左右,这表明模型的CPU端,是较好的分配了任务,提升数据吞吐效率。效果如下图所示,CPU利用率很平均和高效,每个线程是发挥了最大的性能。

    num_workers=8时,CPU利用率和8个连续PID任务

            此时,在用nvidia-smi查看GPU的利用率,几块GPU都在满负荷,满GPU内存,满GPU利用率的处理模型,速度得到巨大提升。

    优化数据加载num_workers=8,和设置batch size的结果

            上图中可以看见,GPU的内存利用率最大化,此时是将batch size设置的较大,占满了GPU的内存,然后将num_workers=8,分配多个子线程,且设置pin_memory=True,直接映射数据到GPU的专用内存,减少数据传输时间。GPU和CPU的数据瓶颈得到解决。整体性能得到权衡。

            此时的运行时间在表中做了统计:

    处理时间统计
    处理阶段时间
    数据加载0.25s
    模型在GPU计算0.21s
    loss反传,参数更新0.43s

    4. 总结

            对上面的分析总结一下,第一是增加batch size,增加GPU的内存占用率,尽量用完内存,而不要剩一半,空的内存给另外的程序用,两个任务的效率都会非常低。第二,在数据加载时候,将num_workers线程数设置稍微大一点,推荐是8,16等,且开启pin_memory=True不要将整个任务放在主进程里面做,这样消耗CPU,且速度和性能极为低下。

                                                                                                                                                                         

                                                                                                                                                                         

                                                                                                                                                                         

            Supplementary:看到大家在评论回复的问题比较多,所以再加一些叙述!

            开这么多线程。第一个,查看你的数据的batch_size,batchsize小了,主CPU直接就加载,处理,而且没有分配到多GPU里面(如果你使用的是多GPU);如果是单GPU,那么就是CPU使劲读数据,加载数据,然后GPU一下就处理完了,你的模型应该是很小,或者模型的FLOPs很小。检查一下模型问题。还有就是,现在这个情况下,开8个线程和1个线程,没什么影响,你开一个num_workers都一样的。如果速度快,没必要分配到多个num_workers去。当数据量大的时候,num_workers设置大,会非常降低数据加载阶段的耗时。这个主要还是应该配合过程。

            在调试过程,命令:top     实时查看你的CPU的进程利用率,这个参数对应你的num_workers的设置;

            命令:   watch -n 0.5 nvidia-smi    每0.5秒刷新并显示显卡设置。

    实时查看你的GPU的使用情况,这是GPU的设置相关。这两个配合好。包括batch_size的设置。

                                                                                                                                                                    时间:2019年9月20日

    5. 再次补充内容

            有很多网友都在讨论一些问题,有时候,我们除了排查代码,每个模块的处理信息之外,其实还可以查一下,你的内存卡,是插到哪一块插槽的。这个插槽的位置,也非常影响代码在GPU上运行的效率。

            大家除了看我上面的一些小的建议之外,评论里面也有很多有用的信息。遇到各自问题的网友们,把他们的不同情况,都描述和讨论了一下,经过交流,大家给出了各自在训练中,CPU,GPU效率问题的一些新的发现和解决问题的方法。

            针对下面的问题,给出一点补充说明:

            问题1: CPU忙碌,GPU清闲。

     数据的预处理,和加载到GPU的内存里面,花费时间。平衡一下batch size, num_workers。

            问题2:CPU利用率低,GPU跑起来,利用率浮动,先增加,然后降低,然后等待,CPU也是浮动。

    • 2.1 下面是具体的步骤和对策:

    在pytorch训练模型时出现以下情况, 情况描述: 首先环境:2080Ti + I7-10700K, torch1.6, cuda10.2, 驱动440 参数设置:shuffle=True, num_workers=8, pin_memory=True; 现象1:该代码在另外一台电脑上,可以将GPU利用率稳定在96%左右 现象2:在个人电脑上,CPU利用率比较低,导致数据加载慢,GPU利用率浮动,训练慢约4倍;有意思的是,偶然开始训练时,CPU利用率高,可以让GPU跑起来,但仅仅几分钟,CPU利用率降下来就上不去了,又回到蜗牛速度。

    •  可以采用的方法:

    两边的配置都一样吗。另一台电脑和你的电脑。你看整体,好像设置配置有点不同。包括硬件,CPU的核,内存大小。你对比一下两台设备。这是第一个。第二个,还是代码里面的配置,代码的高效性。你一来,CPU利用率低,你看一下每一步,卡到哪里,哪里是瓶颈,什么步骤最耗时。都记录一下每一个大的步骤的耗时,然后在分析。测试了每一个大的过程的时间,可以看见,耗时在哪里。主要包括,加载数据,前向传播,反向更新,然后下一步。

    • 2.2 经过测试之后,第二次问题分析:

    经过测试,发现本机卡的地方在加载图像的地方,有时加载10kb左右的图像需要1s以上,导致整个batch数据加载慢!代码应该没有问题,因为在其他电脑能全速跑起来;硬件上,本机的GPU,CPU都强悍,环境上也看不出差距,唯一差在内存16G,其他测试电脑为32G,请问这种现象和内存直接关系大吗?

    • 情况分析

    最多可能就在这边。你可以直接测试batch size为1情况下的整个计算。或者将batch size 开到不同的设置下。看加载数据,计算之间的差值。最有可能就是在这个load data,读取数据这块。 电脑的运行内存16g 32g。其实都已经够了,然后加载到GPU上,GPU内存能放下,影响不大。所以估计是你的内存相对小了,导致的问题。试一下。

    • 2.3 问题定位,解决方法:
    • 这台电脑的内存条插的位置不对,4个插槽的主板,1根内存的时候应该插在第2个插槽(以cpu端参考起),而组装电脑的商家不专业,放在了第4个插槽上,影响性能,更换位置后,速度飞起来了!关于插槽详情,有遇到的朋友去网上收,一大堆!

            在自己电脑,或者自己配的主机上,跑GPU的时候,记得注意查看你自己的内存卡是插到哪一个槽上的。

            补充时间:2021年1月15日

    5.1 再次新补充一些内容

            有网友补充了一些在执行上面的问题中遇到的实际问题,附上他的解决方法。

            使用win 10修改num_workers后可能会报错Broken pipe。

    解决方法:1. 把代码放到if __name__ == "__main__":下运行;或者2.num_workers默认为0即可;或者3. 在Linux进行代码运行

            有一些内容需要说明:在Windows下面,设置num_threads,除了在做数据加载的时候,设置num_workers,还可以用torch.set_num_threads(4)多线程,单线程,都会用多个CPU核,跑多个CPU core的的。只是CPU利用率不高。你设置8线程,12线程,CPU会在每个核上,都进行分配,只是单核的占用率,不一样。即使设置2线程,在6核12线程的CPU,也会在每个核心上,分配计算资源的。只是单核分配的很少。

    5.2 关于加速CPU端训练的方法(无GPU)

            在单独的CPU上,做训练,或者做推理,intel CPU提供了OpenMP 和MKL-DNN的加速库。一般torch或者TensorFlow都做了这一块的优化。可以查看你的pytorch版本,是否支持。

    print(torch.get_num_threads())
    print(torch.__config__.parallel_info())
    
    print(*torch.__config__.show().split("\n"), sep="\n")
    
    
    os.environ["OMP_NUM_THREADS"]="8"  #设置OpenMP计算库的线程数
    os.environ["MKL_NUM_THREADS"]="8"  # 设置MKL-DNN CPU加速库的线程数。
    torch.set_num_threads(8)

    print(torch.get_num_threads())
    print(torch.__config__.parallel_info())

    print(*torch.__config__.show().split("\n"), sep="\n")


    os.environ["OMP_NUM_THREADS"]="8"  #设置OpenMP计算库的线程数
    os.environ["MKL_NUM_THREADS"]="8"  # 设置MKL-DNN CPU加速库的线程数。
    torch.set_num_threads(8)

            分析:

            上面这几个,都可以试一下。看你的pytorch版本,是否在编译之后,支持MKL-DNN加速。为了能控制你使用的线程数,set_num_threads(8) 这个线程数的多少,可以自己按照需求来设定。当你全力跑网络模型,当然设置大点。如果需要留一部分CPU性能来做其他的业务,4线程,6线程?都可以。自己试一试。配合着任务管理器或者htop top 在linux下实时查看CPU使用状态和设置多线程数量的关系。来定性的分配。

            print(torch.__config__.parallel_info()) , 这个函数,查看你的pytorch支持的intel加速库的信息。

            print(*torch.__config__.show().split("\n"), sep="\n") , 这个函数,查看你编译过程中的信息。

            实测结果:

            有没有OpenMP支持,速度影响不是太大。在1-2s内的影响。所采用的pytorch版本是否支持mkl-dnn不影响。在mac arm m1芯片下,开启mkl-dnn,速度比没有开启快4s。44s 与 48s的差别。我们的平台,都是支持mkl-dnn。没有mkl-dnn,速度比有mkl-dnn编译的模型,慢1.5倍左右。

            结论:

            mkl-dnn有无,对性能影响不是很大,1-2x的影响。如果你需要这点性能,那么就要重点检测,你的pytorch版本,是否在编译过程中,设置了use_mkl=on,use_mkldnn=on。大多数情况下,咱们安装的pytorch官方版本,都在build过程中,设置了开启mkl加速选项。这是intel Math Kernel  Library for Deep Neural Networks (Intel® MKL-DNN) 专门针对intel CPU做的CPU端深度学习加速库。

            arm平台下,有无OpenMP和mkl-dnn不确定,要查看这个pytorch是否对arm 这个架构有支持。nvidia的arm平台,jetson这一类的,nvidia自己做了重新编译的,都适配了arm的CPU。

    再提醒一下:以上设置,如果不进行设计,默认为0,会按照最大的性能,来运行。

            补充时间:2021年6月25日。ps:有任何性能加速上遇到的问题,欢迎提出,我经常会查看大家的问题,能回答的都会回答。

    对于如何在Intel CPU,ARM架构CPU,以及Jetson TensorRT上部署,以及部署遇到的速度问题,该如何解决。请查看我的另外一篇文章。

    深度学习模型部署性能分析,Intel和ARM CPU上CNN计算速度差距分析。

    展开全文
  • GPU利用率与使用率

    万次阅读 2019-02-28 14:52:28
    GPU利用率 广义的GPU利用是指对GPU利用率效率,包括GPU空间和时间上的利用效率。 狭义的GPU利用率是指GPU时间片上的利用率; GPU可用的物理资源有哪些? GPU利用资源:SM (计算单元)MEM(存储) Encoder...

    GPU利用率

    广义的GPU利用是指对GPU利用率效率,包括GPU空间和时间上的利用效率。 狭义的GPU利用率是指GPU时间片上的利用率;

     

    GPU可用的物理资源有哪些?

    GPU可利用资源:SM (计算单元)MEM(存储) Encoder(编码) Decoder (解码)

     

    CPU利用率计算方法

     

     

     

    GPU利用不高的原因?

    GPU资源利用不高的原因大致如下:

    1. CPU计算阻塞了GPU的计算
    2. 应用程序大多数解决业务问题,但是忽略了对GPU利用方面的问题。程序需要优化,比如使用多stream,大多数业务只用了default stream。
    3. 对nvidia产品了解不深入,比如DALI。一些GPU资源Encoder和Decoder 没用起来。

     

    1、在需要监控GPU利用率机器上执行命令:

    nvidia-smi --format=csv,noheader,nounits --query-gpu=timestamp,index,memory.total,memory.used,memory.free,utilization.gpu,utilization.memory -lms 500 -f smi-1-90s-instance.log

    该命令生成GPU利用率文件smi-1-90s-instance.log

    待压测结束后,在服务器结束该命令。

     

    2、计算gpu利用率

    cat smi-1-90s-instance.log | awk '{sum7+=$7;count++}END{print sum7/count}'

     计算文件中GPU利用率一列平均值,即为压测时间段内的GPU利用率

     

    单个GPU,比如计算GPU0的利用率

     awk  -F","  '{ if($2==0){print $0} } '  smi-1-90s-instance.log >> test.log

    先导出GPU0的全部数据

    再cat smi-1-90s-instance.log | awk '{sum7+=$7;count++}END{print sum7/count}'

     

    展开全文
  • 计算cpu利用率和内存利用率

    万次阅读 2015-01-20 17:08:29
    Linux 下CPU、内存利用率--计算(二) 当需要频繁地获取,可以选择这种方法。 1、原理 (1) CPU利用率 在Linux下,CPU利用率分为用户态,系统态和空闲态,分别表示CPU处于用户态执行的时间,系统...
       
    
    Linux CPU、内存利用率--计算(二)
    当需要频繁地获取,可以选择这种方法。
    1、原理
    (1)   CPU利用率
    Linux 下, CPU 利用率分为用户态,系统态和空闲态,分别表示 CPU 处于用户态执行的时间,系统内核执行的时间,和空闲系统进程执行的时间,三者之和就是 CPU 的总时间,当没有用户进程、系统进程等需要执行的时候, CPU 就执行系统缺省的空闲进程。从平常的思维方式理解的话, CPU 的利用率就是非空闲进程占用时间的比例,即 CPU 执行非空闲进程的时间  CPU 总的执行时间。
    Linux 系统中, CPU 时间的分配信息保存在 /proc/stat 文件中,利用率的计算应该从这个文件中获取数据。文件的头几行记录了每个 CPU 的用户态,系统态,空闲态等状态下分配的时间片(单位是 Jiffies ),这些数据是从 CPU 加电到当前的累计值。常用的监控软件就是利用 /proc/stat 里面的这些数据来计算 CPU 的利用率的。
    不同版本的 linux /proc/stat 文件内容不一样,以 Linux 2.6 来说, /proc/stat 文件的内容如下:
     
    cpu 2032004 102648 238344 167130733 758440 15159 17878 0
    cpu0 1022597 63462 141826 83528451 366530 9362 15386 0
    cpu1 1009407 39185 96518 83602282 391909 5796 2492 0
    intr 303194010 212852371 3 0 0 11 0 0 2 1 1 0 0 3 0 11097365 0 72615114 6628960 0 179 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
    ctxt 236095529
    btime 1195210746
    processes 401389
    procs_running 1
    procs_blocked 0
     
    第一行的数值表示的是 CPU 总的使用情况,所以我们只要用第一行的数字计算就可以了。下表解析第一行各数值的含义:
    参数 解析(单位:jiffies
    user (2032004) 从系统启动开始累计到当前时刻,用户态的CPU时间,不包含 nice值为负进程。
    nice (102648) 从系统启动开始累计到当前时刻,nice值为负的进程所占用的CPU时间
    system (238344) 从系统启动开始累计到当前时刻,核心时间
    idle (167130733) 从系统启动开始累计到当前时刻,除硬盘IO等待时间以外其它等待时间
    iowait (758440) 从系统启动开始累计到当前时刻,硬盘IO等待时间
    irq (15159) 从系统启动开始累计到当前时刻,硬中断时间
    softirq (17878) 从系统启动开始累计到当前时刻,软中断时间
     
     
    因为 /proc/stat 中的数值都是从系统启动开始累计到当前时刻的积累值,所以需要在不同时间点 t1 t2 取值进行比较运算,当两个时间点的间隔较短时,就可以把这个计算结果看作是 CPU 的即时利用率。
     
    CPU的即时利用率的计算公式:
    CPU t1 t2 时间段总的使用时间  = ( user2+ nice2+ system2+ idle2+ iowait2+ irq2+ softirq2) - ( user1+ nice1+ system1+ idle1+ iowait1+ irq1+ softirq1)
    CPU t1 t2 时间段空闲使用时间  = (idle2 - idle1)
    CPU t1 t2 时间段即时利用率  =  1 - CPU 空闲使用时间  / CPU 总的使用时间
     
     
    2)内存利用率
    计算内存利用率需要从 /proc/meminfo 文件中取相应数据,文件内容如下:
    MemTotal:      1024008 kB
    MemFree:         18448 kB
    Buffers:         12664 kB
    Cached:         282500 kB
    SwapCached:        716 kB
    Active:         816124 kB
    Inactive:        52516 kB
    HighTotal:      122500 kB
    HighFree:          304 kB
     
    … …
     
    MemTotal 数值表示内存总量, MemFree 数值表示空余数量。
    所以内存的即时利用率计算公式
    (MemTotal - MemFree)/ MemTotal
     
     
    2、实现
      这个例子适合于linux内核是2.6版本。Linux的版本问题请参照Linux 下CPU、内存利用率--获取(一)
     

    import  java.io.BufferedReader;
    import  java.io.File;
    import  java.io.FileInputStream;
    import  java.io.IOException;
    import  java.io.InputStreamReader;
    import  java.util.StringTokenizer;


    public   class  MonitorUsageThread  extends  Thread {
        
        
    private final int frequency;//MS
        private static final File memFile = new File("/proc/meminfo");
        
    private static final File statFile = new File("/proc/stat");
        
    private static BufferedReader brMem ;
        
    private static BufferedReader brStat ;
        
    private static InputStreamReader isr = null;
        
        
    private static float cpuUsage;
        
    private static float memUsage;
        
        
    private static boolean on = true;
        
    public MonitorUsageThread(int frequency){
            
    this.frequency = frequency;
        }

        
        
        
    public void run(){
            System.out.println(
    "MonitorUsageThread start run ..................... on: "+on);
            String str 
    = null;
            StringTokenizer tokenMem 
    = null;
            
    int memTotal = 0;
            
    int memFree = 0;
            
    int userStart,niceStart,sysStart,idleStart,iowaitStart,hardirpStart,softirpStart,userEnd,niceEnd,sysEnd,idleEnd,iowaitEnd,hardirpEnd,softirpEnd;
            
    try {
                isr 
    = new InputStreamReader(new FileInputStream(statFile));
                brStat 
    = new BufferedReader(isr);
                StringTokenizer tokenStat 
    = new StringTokenizer(brStat.readLine());
                tokenStat.nextToken();
                userStart 
    = Integer.parseInt(tokenStat.nextToken());
                niceStart 
    = Integer.parseInt(tokenStat.nextToken());
                sysStart 
    = Integer.parseInt(tokenStat.nextToken());
                idleStart 
    = Integer.parseInt(tokenStat.nextToken());
                iowaitStart 
    = Integer.parseInt(tokenStat.nextToken());
                hardirpStart 
    = Integer.parseInt(tokenStat.nextToken());
                softirpStart 
    = Integer.parseInt(tokenStat.nextToken());
                Thread.sleep(frequency);
                
    while(on){
                    isr 
    = new InputStreamReader(new FileInputStream(statFile));
                    brStat 
    = new BufferedReader(isr);
                    tokenStat 
    = new StringTokenizer(brStat.readLine());
                    tokenStat.nextToken();
                    userEnd 
    = Integer.parseInt(tokenStat.nextToken());
                    niceEnd 
    = Integer.parseInt(tokenStat.nextToken());
                    sysEnd 
    = Integer.parseInt(tokenStat.nextToken());
                    idleEnd 
    = Integer.parseInt(tokenStat.nextToken());
                    iowaitEnd 
    = Integer.parseInt(tokenStat.nextToken());
                    hardirpEnd 
    = Integer.parseInt(tokenStat.nextToken());
                    softirpEnd 
    = Integer.parseInt(tokenStat.nextToken());
                    

                    
    int CPUEnd = userEnd+niceEnd+sysEnd+idleEnd+iowaitEnd+hardirpEnd+softirpEnd;
                    
    int CPUStart = userStart+niceStart+sysStart+idleStart+iowaitStart+hardirpStart+softirpStart;
                    System.out.println(
    "idleEnd:"+idleEnd+" , idleStart:"+idleStart+"   ,CPUEnd:"+CPUEnd+" , CPUStart:"+CPUStart);
                    
                    cpuUsage 
    = 1- (float)(idleEnd - idleStart) / (float)(CPUEnd - CPUStart);// cpu usage

                    
    //Gets memory information
                    isr = new InputStreamReader(new FileInputStream(memFile));
                    brMem 
    = new BufferedReader(isr);
                    
                    str 
    = brMem.readLine();
                    tokenMem 
    = new StringTokenizer(str);
                    tokenMem.nextToken();
                    memTotal 
    = Integer.parseInt(tokenMem.nextToken());
                    
                    str 
    = brMem.readLine();
                    tokenMem 
    = new StringTokenizer(str);
                    tokenMem.nextToken();
                    memFree 
    = Integer.parseInt(tokenMem.nextToken());
                            
                    System.out.println(
    "MemTotal:"+memTotal+" , MemFree:"+memFree);
                    memUsage 
    = (float)(memTotal-memFree) / (float)memTotal;// memory usage 
                    
                    userStart 
    = userEnd;
                    niceStart 
    = niceEnd;
                    sysStart 
    = sysEnd;
                    idleStart 
    = idleEnd;
                    iowaitStart 
    = iowaitEnd;
                    hardirpStart 
    = hardirpEnd;
                    softirpStart 
    = softirpEnd;

                    System.out.println(
    "Rate of CPU usage is "+cpuUsage+" , and the memory's is "+memUsage+"  ");
                    Thread.sleep(frequency);
    //
                }

                    
                    
            }
     catch (IOException ioe) {
                System.out.println(ioe.getMessage());
            }
     catch (InterruptedException ie) {
                System.out.println(ie.getMessage());
            }
     finally{
                freeResource();
            }


        }

                  
        
        
    private static void freeResource(){
            
    try{
                
    if(isr!=null)
                    isr.close();
                
    if(brMem!=null)
                    brMem.close();
                
    if(brStat!=null)
                    brStat.close();
            }
    catch(IOException ioe){
                System.out.println(ioe.getMessage());
            }

        }

        
        
    public static float getCPUUsage(){
            
    return cpuUsage;
        }

        
        
        
    public static float getMemoryUsage(){
            
    return memUsage;
        }

        
        
    public static void stopMonitor(){
            on 
    = false;
            freeResource();
        }

        
        
        
        
    public static void main(String[] args){
            MonitorUsageThread thread 
    = new MonitorUsageThread(2000);
            thread.start();
            
    try{
                Thread.sleep(
    10000);//MS
            }
    catch(InterruptedException ie){
                ie.printStackTrace();
            }

            System.out.println();
            System.out.println(
    "-------------CPU usage: "+getCPUUsage());
            System.out.println(
    "-------------Memory usage: "+getMemoryUsage());
            
            
    try{
                Thread.sleep(
    5000);//MS
            }
    catch(InterruptedException ie){
                ie.printStackTrace();
            }

            System.out.println();
            System.out.println(
    "-------------CPU usage: "+getCPUUsage());
            System.out.println(
    "-------------Memory usage: "+getMemoryUsage());
            
            
            thread.stopMonitor();
            System.exit(
    0);
        }

        
    }


    展开全文
  • 系统平均负载(Load average)与CPU利用率

    千次阅读 2011-12-07 10:49:50
    Load Average是CPU的Load,它所包含的信息不是CPU的使用状况,而是在一段时间内CPU正在处理以及等待CPU处理的进程数之和的统计信息,也就是CPU使用队列的长度的统计信息。 通过下面的几个部分的了解,可以一步...
     
    

    在Linux系统中,uptime、w、top等命令都会有系统平均负载load average的输出,那么什么是系统平均负载呢?

    Load Average是CPU的Load,它所包含的信息不是CPU的使用率状况,而是在一段时间内CPU正在处理以及等待CPU处理的进程数之和的统计信息,也就是CPU使用队列的长度的统计信息。

    通过下面的几个部分的了解,可以一步一步的找出Load Average作用。


    CPU时间片

    为了提高程序执行效率,大家在很多应用中都采用了多线程模式,这样可以将原来的序列化执行变为并行执行,任务的分解以及并行执行能够极大地提高程序的运行效率。但这都是代码级别的表现,而硬件是如何支持的呢?那就要靠CPU的时间片模式来说明这一切。程序的任何指令的执行往往都会要竞争CPU这个最宝贵的资源,不论你的程序分成了多少个线程去执行不同的任务,他们都必须排队等待获取这个资源来计算和处理命令。先看看单CPU的情况。下面两图描述了时间片模式和非时间片模式下的线程执行的情况:




    图 1 非时间片线程执行情况




    图 2 非时间片线程执行情况


    在图一中可以看到,任何线程如果都排队等待CPU资源的获取,那么所谓的多线程就没有任何实际意义。图二中的CPU Manager只是我虚拟的一个角色,由它来分配和管理CPU的使用状况,此时多线程将会在运行过程中都有机会得到CPU资源,也真正实现了在单CPU的情况下实现多线程并行处理。

    多CPU的情况只是单CPU的扩展,当所有的CPU都满负荷运作的时候,就会对每一个CPU采用时间片的方式来提高效率。

    在Linux的内核处理过程中,每一个进程默认会有一个固定的时间片来执行命令(默认为1/100秒),这段时间内进程被分配到CPU,然后独占使用。如果使用完,同时未到时间片的规定时间,那么就主动放弃CPU的占用,如果到时间片尚未完成工作,那么CPU的使用权也会被收回,进程将会被中断挂起等待下一个时间片。

    CPU利用率和Load Average的区别

    压力测试不仅需要对业务场景的并发用户等压力参数作模拟,同时也需要在压力测试过程中随时关注机器的性能情况,来确保压力测试的有效性。当服务器长期处于一种超负荷的情况下运行,所能接收的压力并不是我们所认为的可接受的压力。就好比项目经理在给一个人估工作量的时候,每天都让这个人工作12个小时,那么所制定的项目计划就不是一个合理的计划,那个人迟早会垮掉,而影响整体的项目进度。

    CPU利用率在过去常常被我们这些外行认为是判断机器是否已经到了满负荷的一个标准,看到50%-60%的使用率就认为机器就已经压到了临界了。CPU利用率,顾名思义就是对于CPU的使用状况,这是对一个时间段内CPU使用状况的统计,通过这个指标可以看出在某一个时间段内CPU被占用的情况,如果被占用时间很高,那么就需要考虑CPU是否已经处于超负荷运作,长期超负荷运作对于机器本身来说是一种损害,因此必须将CPU的利用率控制在一定的比例下,以保证机器的正常运作。

    Load Average是CPU的Load,它所包含的信息不是CPU的使用率状况,而是在一段时间内CPU正在处理以及等待CPU处理的进程数之和的统计信息,也就是CPU使用队列的长度的统计信息。为什么要统计这个信息,这个信息的对于压力测试的影响究竟是怎么样的,那就通过一个类比来解释CPU利用率和Load Average的区别以及对于压力测试的指导意义。

    我们将CPU就类比为电话亭,每一个进程都是一个需要打电话的人。现在一共有4个电话亭(就好比我们的机器有4核),有10个人需要打电话。现在使用电话的规则是管理员会按照顺序给每一个人轮流分配1分钟的使用电话时间,如果使用者在1分钟内使用完毕,那么可以立刻将电话使用权返还给管理员,如果到了1分钟电话使用者还没有使用完毕,那么需要重新排队,等待再次分配使用。



    图 3 电话使用场景

    上图中对于使用电话的用户又作了一次分类,1min的代表这些使用者占用电话时间小于等于1min,2min表示使用者占用电话时间小于等于2min,以此类推。根据电话使用规则,1min的用户只需要得到一次分配即可完成通话,而其他两类用户需要排队两次到三次。

    电话的利用率 = sum (active use cpu time)/period

    每一个分配到电话的使用者使用电话时间的总和去除以统计的时间段。这里需要注意的是是使用电话的时间总和(sum(active use cpu time)),这与占用时间的总和(sum(occupy cpu time))是有区别的。(例如一个用户得到了一分钟的使用权,在10秒钟内打了电话,然后去查询号码本花了20秒钟,再用剩下的30秒打了另一个电话,那么占用了电话1分钟,实际只是使用了40秒)

    电话的Average Load体现的是在某一统计时间段内,所有使用电话的人加上等待电话分配的人一个平均统计。

    电话利用率的统计能够反映的是电话被使用的情况,当电话长期处于被使用而没有的到足够的时间休息间歇,那么对于电话硬件来说是一种超负荷的运作,需要调整使用频度。而电话Average Load却从另一个角度来展现对于电话使用状态的描述,Average Load越高说明对于电话资源的竞争越激烈,电话资源比较短缺。对于资源的申请和维护其实也是需要很大的成本,所以在这种高Average Load的情况下电话资源的长期“热竞争”也是对于硬件的一种损害。

    低利用率的情况下是否会有高Load Average的情况产生呢?理解占有时间和使用时间就可以知道,当分配时间片以后,是否使用完全取决于使用者,因此完全可能出现低利用率高Load Average的情况。由此来看,仅仅从CPU的使用率来判断CPU是否处于一种超负荷的工作状态还是不够的,必须结合Load Average来全局的看CPU的使用情况和申请情况。

    所以回过头来再看测试部对于Load Average的要求,在我们机器为8个CPU的情况下,控制在10 Load左右,也就是每一个CPU正在处理一个请求,同时还有2个在等待处理。看了看网上很多人的介绍一般来说Load简单的计算就是2* CPU个数减去1-2左右(这个只是网上看来的,未必是一个标准)。

    补充几点:

    1.对于CPU利用率和CPU Load Average的结果来判断性能问题。首先低CPU利用率不表明CPU不是瓶颈,竞争CPU的队列长期保持较长也是CPU超负荷的一种表现。对于应用来说可能会去花时间在I/O,Socket等方面,那么可以考虑是否后这些硬件的速度影响了整体的效率。

    这里最好的样板范例就是我在测试中发现的一个现象:SIP当前在处理过程中,为了提高处理效率,将控制策略以及计数信息都放置在Memcached Cache里面,当我将Memcached Cache配置扩容一倍以后,CPU的利用率以及Load都有所下降,其实也就是在处理任务的过程中,等待Socket的返回对于CPU的竞争也产生了影响。

    2.未来多CPU编程的重要性。现在服务器的CPU都是多CPU了,我们的服务器处理能力已经不再按照摩尔定律来发展。就我上面提到的电话亭场景来看,对于三种不同时间需求的用户来说,采用不同的分配顺序,我们可看到的Load Average就会有不同。假设我们统计Load的时间段为2分钟,如果将电话分配的顺序按照:1min的用户,2min的用户,3min的用户来分配,那么我们的Load Average将会最低,采用其他顺序将会有不同的结果。所以未来的多CPU编程可以更好的提高CPU的利用率,让程序跑的更快。

    以上所提到的内容未必都是很准确或者正确,如果有任何的偏差也请大家指出,可以纠正一些不清楚的概念


    来源:  http://hi.baidu.com/zhuguoneng/blog/item/c739a7eafd2846d8d439c91b.html

    展开全文
  • 从数据传输速率的视角思考信道利用率@(计算机网络)(2014.36)主机甲和主机乙之间使用GBN协议:甲的发送窗口尺寸是1000,数据帧长是1000字节,信道带宽是100Mbps.乙每收到一个数据帧就立即利用一个短数据帧进行确认...
  • 从各种分配策略单独来看,随着申请内存占总内存比率的增大,各种分配策略的内存平均利用率都有所下降,但下降的速率有所差别。相比较而言,平均利用率最大的 best-fit 下降的幅度最大,而平均利用率最小的 worst-fit...
  • CPU利用率与负载的关系

    万次阅读 2016-02-28 22:25:45
    CPU利用率在过去常常被我们这些外行认为是判断机器是否已经到了满负荷的一个标准,看到50%-60%的使用率就认为机器就已经压到了临界了。 CPU利用率是对一个时间段内CPU使用状况的统计,通过这个指标可以看出在某一个...
  • 一、 停止-等待 协议 简介、 二、 "停止-等待协议" 无差错情况、 三、 "停止-等待协议" 有差错情况 ( 帧丢失、帧出错 )、 四、 "停止-等待协议" 有差错情况 ( ACK 确认帧丢失)、 ...七、 信道利用率 计算、
  • 通过top命令查看,当前cpu的平均利用率不到10%,但p进程的cpu利用率高达95%, 我的理解是p进程只占用了其中一个核心,明显的p进程需要更多的cpu资源,那么为 什么操作系统不分配给它更多的cpu资源呢
  • cpu利用率和cpu负载是什么?

    千次阅读 2018-09-22 18:53:23
    我们经常会听到要好好使用cpu的资源,提高cpu利用率,要学习应对高负载的情况,那这个高负载其实大多数情况指的就是cpu负载。我们还会学习到一个命令是top,这个命令可以得到他们的数值和其他系统指标。那么什么是...
  • linux系统性能监控--CPU利用率

    万次阅读 2016-10-12 16:23:48
    在对系统的方法化分析中,首要且最基本的工具之一常常是对系统的 CPU利用率进行简单测量。 Linux以及大多数基于 UNIX的操作系统都提供了一条命令来显示系统的平均负荷(loadaverage) 。[huangc@V-02-01-00860 ~]$ ...
  • Linux系统中的CPU利用率

    千次阅读 2017-10-30 13:48:51
    CPU利用率是系统性能监控的重要指标。CPU利用率是开发人员系统性能优化的重要参考指标。当CPU总体利用率过高时,开发过程中需要根据具体情况进行考虑,在从程序层面优化还是从部署层面优化。
  • 多道程序 cpu利用率

    千次阅读 2015-12-24 22:01:11
    然后在10-15分钟内,有两个进程在运行(1和2),双进程的CPU利用率是36%, 所以,这五分钟内,CPU一共利用了1.8分钟,平均分给每个进程,是0.9分钟。 此时,进程1已经占用了CPU 2.9分钟,还需要0.6分钟,这
  • 描述:华为设备交换机路由器端口利用率计算方法 步骤: 输入命令display interface 100GE1/0/0 查看该端口速率和端口利用率 [huawei]display interface 100GE1/0/0 Last 300 seconds input rate: 158191541 bits/...
  • 1.GPU 占用率,利用率 输入nvidia-smi来观察显卡的GPU内存占用率(Memory-Usage),显卡的GPU利用率(GPU-util) GPU内存占用率(Memory-Usage) 往往是由于模型的大小以及batch size的大小,来影响这个指标 显卡的...
  • CPU利用率和Load Average的区别

    千次阅读 2016-06-01 14:16:54
    理解CPU利用率和load average的关系
  • Linux如何统计进程的CPU利用率

    千次阅读 2018-06-28 09:01:09
    1. 如何统计进程CPU利用率1.0 概述在Linux的/proc文件系统,可以看到自启动时候开始,所有CPU消耗的时间片;对于个进程,也可以看到进程消耗的时间片。这是一个累计值,可以"非阻塞"的输出。获得一定时间...
  • 作用:以1秒为信息采集周期,采集10次程序“admin”的CPU统计信息,最后一行会输出10次统计信息的平均值。 注:如要测试服务器的CPU使用情况,同时应对此服务器进行模拟请求,如使用Apache的基准测试工具“ab”: ...
  • CPU实时利用率计算方法

    千次阅读 2016-08-16 17:52:27
    在Linux下,CPU利用率分为用户态,系统态和空闲态,分别表示CPU处于用户态执行的时间,系统内核执行的时间,和空闲系统进程执行的时间,三者之和就是CPU的总时间,当没有用户进程、系统进程等需要执行的时候,CPU就...
  • 数字通信系统中的频带利用率

    千次阅读 2019-07-27 21:22:00
    频带利用率的定义 在数字通信系统中,频带利用率被定义为带宽(每赫)内的传输速度,即 \[ η = \dfrac{R_B}{B} (Baud/Hz) \tag{1}\]或是\[ η = \dfrac{R_b}{B} (b/(s*Hz)) \tag{2}\]其中\(R_B\)表示码元传输速率,...
  • 在SLES 9下查看线程的cpu利用率

    千次阅读 2010-01-05 20:09:00
    怎样在SLES 9下查看线程的cpu利用率 在 Linux 下 top 工具能够显示 cpu 的平均利用率(user,nice,system,idle,iowait,irq,softirq,etc.),能够显示每个 cpu 的利用率。但是无法显示每个线程的 cpu 利用率情况,这时就...
  • CPU负载和CPU利用率浅析

    万次阅读 2018-07-04 15:43:34
    CPU利用率是指CPU工作时间占总时间的比重,公式如下: Utilization= work_time/total_time, 其中,total_time=work_time+idle_ime. 可见,总时间由一段连续时间内的CPU工作时间长度和CPU空闲时间长度组成。举个...
  • CPU利用率的计算

    千次阅读 2016-12-08 09:37:51
    尽管uptime仅有两个数值,但是表示总时间和CPU为idle的时间,已足以计算CPU的利用率,即delta(第一个数值-第二个数值)/delta(第一个数值) 求各CPU单独的利用率的代码: public class CpuUseInfo { String cpu...
  • Ubuntu查看CPU及CPU利用率

    千次阅读 2014-04-30 14:01:46
    查看机子有几个CPU以及每个CPU的详细信息 ...查看CPU的利用率  先执行top命令,再按1,可以看到每个CPU的利用率  显示的信息中%us的值,表示CPU使用了多少 CPU %user %system %n
  • 所谓的性能,是负载、吞吐量、接受的响应时间和资源利用率之间的一种平衡。 通过一个理发店的例子,然后引出最佳并发用户数和最大并发用户数的概念 背景:理发店共有3名理发师,每名理发师完成一次理发都耗时1...
  • 用户A与用户B通过卫星链路通信时,传播延迟为270ms,假设数据速率为64kb/s,帧长为4000bit,若采用停止等待ARQ协议通信,则最大链路利用率为(1);若采用退后N帧ARQ协议通信,发送窗口为8,则最大链路利用率可以达到...
  • 可能很多人仍然无法搞明白Linux下CPU利用率和CPU负载的含义以及区别,本文将简单介绍这两者的含义和区别
  • linux下C语言实现求CPU利用率

    万次阅读 2014-10-09 08:54:49
    本来就是想通过写个小程序测试CPU利用率从而可以检验其他的工具性能之类的数据,后来参照IPbench中的cpu_target_lukem插件实现我们的功能,原理很简单:就是我们给程序设置了极低的优先级,如果有任何计算任务都会...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 186,524
精华内容 74,609
关键字:

平均可利用率