精华内容
下载资源
问答
  • 一、 停止-等待 协议 简介、 二、 "停止-等待协议" 无差错情况、 三、 "停止-等待协议" 有差错情况 ( 帧丢失、帧出错 )、 四、 "停止-等待协议" 有差错情况 ( ACK 确认帧丢失)、 ...七、 信道利用率 计算





    一、 停止-等待 协议 简介



    停止-等待 协议 解决的问题 :

    • 可靠传输 : 解决 由于 物理线路 , 设备故障 , 路由错误 等各种问题导致的 丢包问题 ;
    • 流量控制 : 实现 发送端 与 接收端 的 流量控制 ;

    停止-等待 协议 讨论场景 : 只考虑 一方为发送方 , 一方为接收方 ; 相当于 单工通信场景 ;


    停止-等待 协议内容 : 发送方 每 发送完一个 数据帧 ( 分组 / 数据报 ) , 就停止发送 , 等待接收端确认 , 接收到 接收端 确认信息后 , 再发送下一个分组数据 ;


    停止-等待 协议 应用场景 :

    • 无差错情况
    • 有差错情况




    二、 “停止-等待协议” 无差错情况



    "停止-等待协议" 无差错情况 :

    发送方 0 : 发送 0 0 0 帧 ;

    接收方 0 : 接收 0 0 0 帧 , 并返回 0 0 0 帧 确认信息 ACK 0 0 0 ;

    发送方 1 : 收到 ACK 0 0 0 确认帧后 , 发送 1 1 1 帧 ;

    接收方 1 : 接收 1 1 1 帧 , 并返回 1 1 1 帧 确认信息 ACK 1 1 1 ;

    发送方 0 : 收到 ACK 1 1 1 确认帧后 , 发送 0 0 0 ; 注意此处的 0 0 0 帧 与 上面的 只是序号相同 , 数据不同 ;

    接收方 0 : 接收 0 0 0 帧 , 并返回 0 0 0 帧 确认信息 ACK 0 0 0 ;


    发送方 每发送一个数据帧 , 就停止等待 , 数据帧编号 使用 1 1 1 bit 编号就足够了 ;


    上述过程是理想传输的情况 , 发送 与 接收 都没有差错产生 , 没有丢包 ;





    三、 “停止-等待协议” 有差错情况 ( 帧丢失、帧出错 )



    差错的情况 :

    • 数据帧 丢失
    • 检测到 帧 错误

    "停止-等待协议" 有差错情况 :

    发送方 0 : 发送 0 0 0 帧 ;

    接收方 0 : 接收 0 0 0 帧 , 并返回 0 0 0 帧 确认信息 ACK 0 0 0 ;

    发送方 1 : 收到 ACK 0 0 0 确认帧后 , 发送 1 1 1 帧 ;

    帧丢失 : 发送过程中 , 链路出现故障 , 1 1 1 帧 丢失 , 接收方没有收到 1 1 1 帧 , 自然不会 向发送方 发送帧确认信息 ;

    帧出错 : 接收方没有收到 1 1 1 帧 , 但是校验后 , 该帧是错误帧 , 也不会 向发送方 发送帧确认信息 ;

    发送方 1 : 超时计时器 在每次发送时 , 都会启动自动计时 , 当超时后 , 发送方会重新发送 1 1 1 帧 ;

    接收方 1 : 接收 1 1 1 帧 , 并返回 1 1 1 帧 确认信息 ACK 1 1 1 ;


    超时重传机制:

    ① 超时计时器 : 发送方 每次 发送 数据帧 后 , 就会自动开始计时 ;

    ② 超时时间 : 超时重发的重传时间 , 比 帧传出的 平均 往返延迟 ( RTT ) 长 ;

    ③ 保留副本 : 发送方 发送完 数据帧后 , 必须 保留副本 , 以免丢包需要重传 ;

    ④ 帧编号 : 数据帧 与 确认帧 必须编号 ;





    四、 “停止-等待协议” 有差错情况 ( ACK 确认帧丢失)



    "停止-等待协议" 有差错情况 :

    发送方 0 : 发送 0 0 0 帧 ;

    接收方 0 : 接收 0 0 0 帧 , 并返回 0 0 0 帧 确认信息 ACK 0 0 0 ;

    发送方 1 : 收到 ACK 0 0 0 确认帧后 , 发送 1 1 1 帧 ;

    接收方 1 : 接收 1 1 1 帧 , 并返回 1 1 1 帧 确认信息 ACK 1 1 1 ;

    ACK 确认帧丢失 : 上述发出的 ACK 1 1 1 确认帧 丢失 , 发送方没有接收 确认帧 ;

    ACK 确认帧延迟 : 上述发出的 ACK 1 1 1 确认帧 出现很大的延迟 , 发送方没有接收 确认帧 ;

    发送方 1 : 超时计时器 在每次发送时 , 都会启动自动计时 , 当超时后 , 发送方会重新发送 1 1 1 帧 ;

    接收方 1 : 接收 1 1 1 帧 , 丢弃掉重复的 1 1 1 帧 , 并返回 1 1 1 帧 确认信息 ACK 1 1 1 ;


    如果发送方 在 某个时刻 接收到 迟到的 ACK 确认帧 , 发现该数据帧是之前已经处理过的数据帧 , 直接丢弃该 ACK 确认帧即可 ;





    五、 “停止-等待协议” 性能分析



    "停止-等待协议" 性能分析 :

    优点 : 简单

    缺点 : 信道利用率 低 ;



    信道利用率 :

    U = T D T D + R T T + T A U = \cfrac{T_D}{T_D + RTT + T_A} U=TD+RTT+TATD

    U U U 是信道利用率 ;

    T D T_D TD 是发送方发送延迟 , 即发送方用了多长时间将数据帧发送完毕 ;

    R T T RTT RTT 是往返时延 ;

    T A T_A TA 是接收方 发送 A C K ACK ACK 确认帧 的时延 ;


    "停止-等待协议" 信道利用率很低 , 大部分事件都在 传输的延迟上 , 用于发送接收的时间很少 ;





    六、 信道利用率 公式



    信道利用率 是 发送方 , 在一个发送周期内 , 有效发送数据所占用的时间 , 占整个发送周期的比例 ;

    信 道 利 用 率 = L C T 信道利用率 = \cfrac{\dfrac{L}{C}}{T} =TCL

    L L L 是发送的数据比特数 ;

    C C C 是发送方的速率 ;

    其中 L C \cfrac{L}{C} CL 是发送时延 ;

    T T T 是发送的周期 , 即从开始发送 , 到收到第一个确认帧为止的时间 ;



    信 道 吞 吐 率 = 信 道 利 用 率 × 发 送 方 的 发 送 速 率 信道吞吐率 = 信道利用率 \times 发送方的发送速率 =×





    七、 信道利用率 计算



    信道传输速率 4000b/s , 单向传播时延 30ms , 使 “停止-等待” 协议 信道利用率达到 80% , 数据帧长度至少是多少 ? ? ?


    信道利用率公式为 :

    U = T D T D + R T T + T A U = \cfrac{T_D}{T_D + RTT + T_A} U=TD+RTT+TATD


    先把数据单位收拾下 , 传输速率 4000 比特 / 秒 , 单向传播时延 0.03 秒 , RTT 是 0.06 秒 ; 设 数据帧长度是 L L L 比特 ; 这里没有给出 ACK 发送延迟 , 当做 0 0 0 ;

    L 4000 L 4000 + 0.06 + 0 = 0.8 \cfrac{\dfrac{L}{4000}}{\dfrac{L}{4000} + 0.06 + 0} = 0.8 4000L+0.06+04000L=0.8


    分子分母都乘以 4000 4000 4000 ;


    L L + 240 = 0.8 \cfrac{L}{L+ 240} = 0.8 L+240L=0.8

    L = 0.8 L + 192 L= 0.8 L + 192 L=0.8L+192

    0.2 L = 192 0.2L= 192 0.2L=192

    L = 960 L= 960 L=960 单位是 比特 ;

    数据帧的长度至少是 960 960 960 比特 ;

    展开全文
  • CPU实时利用率计算方法

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

    http://blog.csdn.net/nineday/archive/2007/12/11/1928847.aspx

    在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总的使用时间

     

    这些值是谁,什么时候记录的呢?

    每次timer的中断就会记录一次,记录在struct cpu_usage_stat 里,实现在timer_tick ->update_process_times里。
    那么它的精度就是HZ,如果HZ是100,就意味着每S记录100次。这个精度当然是不高的,而且容易出错,下面是在Documentation/cpu-load.txt中的一个例子:
      time line between two timer interrupts
     |--------------------------------------|
     ^                                    ^
     |_ user appA begins working          |
                                          |_ user appA goes to sleep
    结果这个A的动作没有被记录下来,这一S有可能被记录到其他的头上。如果你做的程序正好是那个其他,你就会抱怨说,这真是一陀屎呀。
    那么有没有高精度的记录呢?
    有,但是要自己写,就算你用oprofile之类的,他的原理也是用timer_interrupt记录的,你可以用其他的高精度timer,但是,频繁的中断会把系统弄死。所以要自己写,假设有一个高精度的硬件counter,好像x86下的TimeStamp Counter,
    在cpu_idle 里记录idle的时间,在asm_do_IRQ里记录处理irq的时间,在context_switch记录进入了那个process,以及时间,在__do_softirq里记录处理softirq的时间,把这些东西记录在一块全局数组里。
     
     
     
     
    也可以参考busybox中top的实现(在busybox/procps/top.c)
    展开全文
  • 计算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);
        }

        
    }


    展开全文
  • LINUX CPU利用率计算

    万次阅读 2011-08-22 21:54:27
    总的Cpu使用率计算 计算方法: 1、 采样两个足够短的时间间隔的Cpu快照,分别记作t1,t2,其中t1、t2的结构均为: (user、nice、system、idle、iowait、irq、softirq、stealstolen、guest)的9元组; 2、...

    proc文件系统

    /proc文件系统是一个伪文件系统,它只存在内存当中,而不占用外存空间。它以文件系统的方式为内核与进程提供通信的接口。用户和应用程序可以通过/proc得到系统的信息,并可以改变内核的某些参数。由于系统的信息,如进程,是动态改变的,所以用户或应用程序读取/proc目录中的文件时,proc文件系统是动态从系统内核读出所需信息并提交的。

    /proc目录中有一些以数字命名的目录,它们是进程目录。系统中当前运行的每一个进程在/proc下都对应一个以进程号为目录名的目录/proc/pid,它们是读取进程信息的接口。此外,在Linux2.6.0-test6以上的版本中/proc/pid目录中有一个task目录,/proc/pid/task目录中也有一些以该进程所拥有的线程的线程号命名的目录/proc/pid/task/tid,它们是读取线程信息的接口。

    /proc/cpuinfo文件

             该文件中存放了有关 cpu的相关信息(型号,缓存大小等)。

    [zhengangen@buick ~]$ cat /proc/cpuinfo

    processor       : 0

    vendor_id       : GenuineIntel

    cpu family      : 15

    model           : 4

    model name      : Intel(R)Xeon(TM) CPU 3.00GHz

    stepping        : 10

    cpu MHz         : 3001.177

    cache size      : 2048 KB

    physical id     : 0

    siblings        : 2

    core id         : 0

    cpu cores       : 1

    fdiv_bug        : no

    hlt_bug         : no

    f00f_bug        : no

    coma_bug        : no

    fpu             : yes

    fpu_exception   : yes

    cpuid level     : 5

    wp              : yes

    flags           : fpu vme de psetsc msr pae mce cx8 apic mtrr pge mca cmov pat pse36 clflush dts acpi mmx fxsrsse sse2 ss ht tm pbe lm pni monitor ds_cpl cid xtpr

    bogomips        : 6004.52

     

    说明:以下只解释对我们计算Cpu使用率有用的相关参数。

             参数                            解释

    processor (0)                       cpu的一个物理标识

     

    结论1:可以通过该文件根据processor出现的次数统计cpu的逻辑个数(包括多核、超线程)。

    /proc/stat文件

             该文件包含了所有CPU活动的信息,该文件中的所有值都是从系统启动开始累计到当前时刻。不同内核版本中该文件的格式可能不大一致,以下通过实例来说明数据该文件中各字段的含义。

    实例数据:2.6.24-24版本上的

     

    fjzag@fjzag-desktop:~$cat /proc/stat

    cpu  38082 627 27594 89390812256 581 895 0 0

    cpu022880 472 16855 430287 10617 576 661 0 0

    cpu115202 154 10739 463620 1639 4 234 0 0

    intr120053 222 2686 0 1 1 0 5 0 3 0 0 0 47302 0 0 34194 29775 0 5019 845 0 0 0 0 00 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 00 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 00 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 00 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 00 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

    ctxt1434984

    btime1252028243

    processes8113

    procs_running1

    procs_blocked0

    第一行的数值表示的是CPU总的使用情况,所以我们只要用第一行的数字计算就可以了。下表解析第一行各数值的含义:

    参数          解析(单位:jiffies)

    (jiffies是内核中的一个全局变量,用来记录自系统启动一来产生的节拍数,在linux中,一个节拍大致可理解为操作系统进程调度的最小时间片,不同linux内核可能值有不同,通常在1ms到10ms之间)

    user (38082)    从系统启动开始累计到当前时刻,处于用户态的运行时间,不包含 nice值为负进程。

    nice (627)      从系统启动开始累计到当前时刻,nice值为负的进程所占用的CPU时间

    system (27594)  从系统启动开始累计到当前时刻,处于核心态的运行时间

    idle (893908)   从系统启动开始累计到当前时刻,除IO等待时间以外的其它等待时间iowait (12256) 从系统启动开始累计到当前时刻,IO等待时间(since 2.5.41)

    irq (581)           从系统启动开始累计到当前时刻,硬中断时间(since 2.6.0-test4)

    softirq (895)      从系统启动开始累计到当前时刻,软中断时间(since2.6.0-test4)stealstolen(0)                   which is the time spent in otheroperating systems when running in a virtualized environment(since 2.6.11)

    guest(0)                               whichis the time spent running a virtual CPU  for  guest operating systems under the control ofthe Linux kernel(since 2.6.24)

     

    结论2:总的cpu时间totalCpuTime = user + nice+ system + idle + iowait + irq + softirq + stealstolen +  guest

    /proc/<pid>/stat文件                                          

    该文件包含了某一进程所有的活动的信息,该文件中的所有值都是从系统启动开始累计

    到当前时刻。以下通过实例数据来说明该文件中各字段的含义。

     

    [zhengangen@buick ~]# cat/proc/6873/stat

    6873 (a.out) R 6723 6873 6723 34819 6873 8388608 77 0 0 0 41958 31 0 0 25 0 3 05882654 1409024 56 4294967295 134512640 134513720 3215579040 0 2097798 0 0 0 00 0 0 17 0 0 0

     

    说明:以下只解释对我们计算Cpu使用率有用相关参数

    参数                                                               解释

    pid=6873                            进程号

    utime=1587                       该任务在用户态运行的时间,单位为jiffies

    stime=41958                      该任务在核心态运行的时间,单位为jiffies

    cutime=0                            所有已死线程在用户态运行的时间,单位为jiffies

    cstime=0                            所有已死在核心态运行的时间,单位为jiffies

     

    结论3:进程的总Cpu时间processCpuTime = utime +stime + cutime + cstime,该值包括其所有线程的cpu时间。

    /proc/<pid>/task/<tid>/stat文件

    该文件包含了某一进程所有的活动的信息,该文件中的所有值都是从系统启动开始累计到当前时刻。该文件的内容格式以及各字段的含义同/proc/<pid>/stat文件。

             注意,该文件中的tid字段表示的不再是进程号,而是linux中的轻量级进程(lwp),即我们通常所说的线程。

     

    结论4:线程Cpu时间threadCpuTime = utime +stime

    系统中有关进程cpu使用率的常用命令

    ps 命令

    通过ps命令可以查看系统中相关进程的Cpu使用率的信息。以下在linux man文档中对ps命令输出中有关cpu使用率的解释:

     

    CPU usage is currentlyexpressed as the percentage of time spent running during the entire lifetime ofa process. This is not ideal, and it does not conform to the standards that psotherwise conforms to. CPU usage is unlikely to add up to exactly 100%.

     

    %cpu   cpu utilization of the process in"##.#" format. It is the CPU time used                           divided by the timethe process has been running (cputime/realtime ratio),                           expressed as apercentage. It will not add up to 100% unless you are lucky.

     

    结论5:ps命令算出来的cpu使用率相对于进程启动时的平均值,随着进程运行时间的增大,该值会趋向于平缓。

    top命令

    通过top命令可以查看系统中相关进程的实时信息(cpu使用率等)。以下是man文档中对top命令输出中有关进程cpu使用率的解释。

     

    #C  -- Last used CPU (SMP)                   Anumber representing the last used processor. In a true  SMP environment  this  will likely change  frequently  since the  kernel intentionally usesweak affinity.  Also, the very act ofrunning top may break this weak affinity and cause more processes to  change CPUs  more  often (because of the extra demand for cputime).

     

    %CPU  --  CPUusage                   The  task’s share ofthe elapsed CPU time since the last screen update, expressed as a percent-ageof total CPU time.  In a true SMP environment, if  Irix mode is Off, top will operate in Solaris modewhere a task’s cpu usage will be divided by the total number of CPUs.

     

    结论6:某一个线程在其运行期间其所使用的cpu可能会发生变化。

    结论7:在多核的情况下top命令输出的cpu使用率实质是按cpu个数*100%计算的。

    单核情况下Cpu使用率的计算

    基本思想

    通过读取/proc/stat 、/proc/<pid>/stat、/proc/<pid>/task/<tid>/stat以及/proc/cpuinfo这几个文件获取总的Cpu时间、进程的Cpu时间、线程的Cpu时间以及Cpu的个数的信息,然后通过一定的算法进行计算(采样两个足够短的时间间隔的Cpu快照与进程快照来计算进程的Cpu使用率)。

     

    总的Cpu使用率计算

    计算方法:

    1、  采样两个足够短的时间间隔的Cpu快照,分别记作t1,t2,其中t1、t2的结构均为:

    (user、nice、system、idle、iowait、irq、softirq、stealstolen、guest)的9元组;

    2、  计算总的Cpu时间片totalCpuTime

    a)        把第一次的所有cpu使用情况求和,得到s1;

    b)        把第二次的所有cpu使用情况求和,得到s2;

    c)        s2 - s1得到这个时间间隔内的所有时间片,即totalCpuTime = j2 - j1 ;

    3、计算空闲时间idle

    idle对应第四列的数据,用第二次的第四列- 第一次的第四列即可

    idle=第二次的第四列- 第一次的第四列

    6、计算cpu使用率

    pcpu =100* (total-idle)/total

    某一进程Cpu使用率的计算

    计算方法:  

    1.              采样两个足够短的时间间隔的cpu快照与进程快照,

    a)        每一个cpu快照均为(user、nice、system、idle、iowait、irq、softirq、stealstolen、guest)的9元组;

    b)        每一个进程快照均为 (utime、stime、cutime、cstime)的4元组;

    2.              分别根据结论2、结论3计算出两个时刻的总的cpu时间与进程的cpu时间,分别记作:totalCpuTime1、totalCpuTime2、processCpuTime1、processCpuTime2

    3.              计算该进程的cpu使用率pcpu = 100*(processCpuTime2 – processCpuTime1) / (totalCpuTime2 – totalCpuTime1) (按100%计算,如果是多核情况下还需乘以cpu的个数);

    实验数据

    实验一: 监控一空循环的进程的cpu使用率。

    说明:左边的数据是按以上算法得到的数据,其中采样的时间间隔与top命令刷新屏幕的时间间隔相同。

    按以上方法计算得到的cpu使用率

    通过top命令得到的

     

    99.50083

    98.333336

    98.0

    98.83138

    99.0

    99.0

    99.83361

    98.83527

    98.4975

     

    PID    USER      PR   NI   VIRT   RES   SHR   S  %CPU %MEM  TIME+  COMMAND 

    7639 fjzag     20   0  206m  10m 7136 S   99  2.2   1:00.74 java              

     7639 fjzag     20   0  206m  10m 7136 S   99  2.2   1:03.71 java              

     7639 fjzag     20   0  206m  10m 7136 S   99  2.2   1:06.67 java              

     7639 fjzag     20   0  206m  10m 7136 S   99  2.2   1:09.63 java              

     7639 fjzag     20   0  206m  10m 7136 S   98  2.2   1:12.59 java              

     7639 fjzag     20   0  206m  10m 7136 S   99  2.2   1:15.55 java              

     7639 fjzag     20   0  206m  10m 7136 S  100  2.2   1:18.55 java              

     7639 fjzag     20   0  206m  10m 7136 S  100  2.2   1:21.54 java              

     7639 fjzag     20   0  206m  10m 7136 S   99  2.2   1:24.52 java              

     7639 fjzag     20   0  206m  10m 7136 S   98  2.2   1:27.46 java

     

    实验二: 监控jconsole进程的cpu使用率。

    说明:左边的数据是按以上算法得到的数据,其中采样的时间间隔与top命令刷新屏幕的时间间隔相同。

    按以上方法计算得到的cpu使用率

    通过top命令得到的

     

    8.681135

    12.0

    10.350584

    7.6539097

    7.6539097

    5.0

    13.021703

    11.0

    8.666667

    PID   USER      PR   NI  VIRT   RES   SHR  S  %CPU %MEM  TIME+  COMMAND 

    7753 fjzag     20   0  252m  72m  22m S   10 14.4   0:18.70 jconsole          

     7753 fjzag     20   0  252m  72m  22m S   12 14.4   0:19.07 jconsole          

     7753 fjzag     20   0  252m  72m  22m S   11 14.4   0:19.39 jconsole          

     7753 fjzag     20   0  252m  72m  22m S    7 14.4   0:19.61 jconsole          

     7753 fjzag     20   0  252m  72m  22m S    7 14.4   0:19.83 jconsole          

     7753 fjzag     20   0  252m  72m  22m S    5 14.4   0:19.97 jconsole          

     7753 fjzag     20   0  252m  72m  22m S   14 14.4   0:20.38 jconsole          

     7753 fjzag     20   0  252m  72m  22m S   10 14.4   0:20.68 jconsole          

     7753 fjzag     20   0  252m  72m  22m S    9 14.5   0:20.96 jconsole

    某一线程Cpu使用率的计算

    计算方法:  

    1.              采样两个足够短的时间隔的cpu快照与线程快照,

    a)        每一个cpu快照均为(user、nice、system、idle、iowait、irq、softirq、stealstealon、guest)的9元组;

    b)        每一个线程快照均为 (utime、stime)的2元组;

    2.              分别根据结论2、结论4计算出两个时刻的总的cpu时间与线程的cpu时间,分别记作:totalCpuTime1、totalCpuTime2、threadCpuTime1、threadCpuTime2

    3.              计算该线程的cpu使用率pcpu = 100*( threadCpuTime2– threadCpuTime1) / (totalCpuTime2– totalCpuTime1) (按100%计算,如果是多核情况下还需乘以cpu的个数);

    实验数据

    实验一: 监控一空循环的线程的cpu使用率。

    说明:左边的数据是按以上算法得到的数据,其中采样的时间间隔与top命令刷新屏幕的时间间隔相同。

    按以上方法计算得到的cpu使用率

    通过top命令得到的

     

    98.83138

    97.00997

    96.98997

    97.49583

    98.169716

    96.8386

    97.333336

    93.82304

    98.66667

    PID    USER      PR   NI   VIRT   RES   SHR   S  %CPU %MEM  TIME+  COMMAND 

    7649 fjzag     20   0  206m  10m 7136 R   97  2.2   7:22.94 java              

     7649 fjzag     20   0  206m  10m 7136 R   97  2.2   7:25.86 java              

     7649 fjzag     20   0  206m  10m 7136 R   97  2.2   7:28.76 java              

     7649 fjzag     20   0  206m  10m 7136 R   99  2.2   7:31.72 java              

     7649 fjzag     20   0  206m  10m 7136 R   98  2.2   7:34.65 java              

     7649 fjzag     20   0  206m  10m 7136 R   96  2.2   7:37.53 java              

     7649 fjzag     20   0  206m  10m 7136 R   98  2.2   7:40.47 java              

     7649 fjzag     20   0  206m  10m 7136 R   96  2.2   7:43.34 java              

     7649 fjzag     20   0  206m  10m 7136 R   97  2.2   7:46.25 java

     

    实验二: 监控jconsole程序某一线程的cpu使用率。

    说明:左边的数据是按以上算法得到的数据,其中采样的时间间隔与top命令刷新屏幕的时间间隔相同。

    按以上方法计算得到的cpu使用率

    通过top命令得到的

     

    1.3400335

    6.644518

    1.3333334

    0.6677796

    0.6666667

    1.3333334

    1.3333334

     PID    USER      PR   NI   VIRT   RES  SHR  S  %CPU %MEM  TIME+  COMMAND 

    7755 fjzag     20   0  251m  72m  22m S    1 14.4   0:11.92 jconsole          

     7755 fjzag     20   0  251m  72m  22m S    7 14.4   0:12.12 jconsole          

     7755 fjzag     20   0  251m  72m  22m S    2 14.4   0:12.18 jconsole          

     7755 fjzag     20   0  251m  72m  22m S    0 14.4   0:12.18 jconsole          

     7755 fjzag     20   0  251m  72m  22m S    1 14.4   0:12.20 jconsole          

     7755 fjzag     20   0  251m  72m  22m S    1 14.4   0:12.24 jconsole          

     7755 fjzag     20   0  251m  72m  22m S    1 14.4   0:12.28 jconsole

    多核情况下cpu使用率的计算                                                    

    以下通过实验数据来说明多核情况下某一进程cpu使用率是按cpu个数*100%计算的.

    实验一

    描述:

    双核的情况下作的一组实验,第一组数据是通过ps  -eLo pid,lwp,pcpu | grep 9140命令查看进程号为9140的进程中各线程的详细信息。第二组数据是通过 ps命令查看进程号为9140进程的cpu使用率。

    数据一:

    pid   lwp  %cpu

    9140  9140  0.0
     9140  9141  0.0
     9140  9142  0.0
     9140  9143  0.0
     9140  9144  0.0
     9140  9149  0.0
     9140  9150  0.0
     9140  9151  0.0
     9140  9152  0.1
     9140  9153 96.6                         该线程是一个空循环
     9140  9154 95.9                         该线程是一个空循环

    以上除了红色标注出来的两个线程以外,其他的线程都是后台线程。

    数据二:

    pid   %cpu

    9140  193

    实验二

    描述:

    单核的情况下作的一组实验,第一组数据是通过ps  -eLo pid,lwp,pcpu | grep 6137命令查看进程号为6137的进程中各线程的详细信息。第二组数据是通过 ps命令查看进程号为6137进程的cpu使用率。

    数据一:

     pid    lwp  %cpu

     6137 6137  0.0

     6137 6138  0.1

     6137 6143  0.0

     6137 6144  0.0

     6137 6145  0.0

     6137 6146  0.0

     6137 6147  0.0

     6137 6148  0.0

     6137 6149  0.0

     6137 6150 46.9                                                 空循环线程

     6137 6151 46.9                                                 空循环线程

    以上除了红色标注出来的两个线程以外,其他的线程都是后台线程。

    数据二

    pid %cpu

    6137 92.9

    主要问题:

    1.      不同内核版本/proc/stat文件格式不大一致。/proc/stat文件中第一行为总的cpu使用情况。

    各个版本都有的4个字段: user、nice、system、idle

    2.5.41版本新增字段:iowait

    2.6.0-test4新增字段:irq、softirq

    2.6.11新增字段:stealstolen:                    which is thetime spent in other operating

    systems whenrunning in a virtualized environment

    2.6.24新增字段:guest:                                    whichis the time spent running a virtual CPU  for  guest operating systems under the control ofthe Linux kernel

    2./proc/pid/task目录是Linux 2.6.0-test6之后才有的功能。

     

    3.关于出现cpu使用率为负的情况,目前想到的解决方案是如果出现负值,连续采样计算cpu使用率直到为非负。

     

    4.有些线程生命周期较短,可能在我们采样期间就已经死掉了.

    展开全文
  • 磁盘IO利用率计算

    万次阅读 2010-06-29 00:09:00
    因为发出的 I/O 请求太多 (每秒钟约 29 个),假设这些请求是同时发出的,那么平均等待时间可以这样计算: 平均等待时间 = 单个 I/O 服务时间 * ( 1 + 2 + … + 请求总数-1) / 请求总数 应用到上面的例子: 平均...
  • CPU利用率计算

    千次阅读 2016-12-08 09:37:51
    尽管uptime仅有两个数值,但是表示总时间和CPU为idle的时间,已足以计算CPU的利用率,即delta(第一个数值-第二个数值)/delta(第一个数值) 求各CPU单独的利用率的代码: public class CpuUseInfo { String cpu...
  • 可以用下面的命令将 cpu 占用高的线程找出来: ps H -eo user,pid,ppid,tid,time,%cpu,cmd --sort=%cpu这个命令首先指定参数'H',显示线程相关的信息,格式输出中包含:user,pid,ppid,tid,time,%cpu,cmd,然后再用%...
  • 减脂心跳的计算公式

    千次阅读 2015-11-06 10:55:19
    减脂心跳的计算公式 初级公式 普通公式 卡福能公式
  • 为此我还专门推算了一个近似的计算公式供大家参考。  完整的基金定投收益计算公式: M=a(1+x)[-1+(1+x)^n]/x M:预期收益 a:每期定投金额 x:收益 n:定投期数(公式中为n次方) 注意a、x和n的匹配,月定投金额...
  • 视频码率计算公式

    千次阅读 2011-07-14 10:11:25
    ●RMVB 格式:这是一种由RM视频格式升级延伸出的新视频格式,它的先进之处在于RMVB视频格式打破了原先RM格式那种平均压缩采样的方式,在保证平均压缩比的基础上合理利用比特率资源,就是说静止和动作场面少的画面...
  • 网络带宽利用率的一般计算方法

    千次阅读 2013-01-21 12:23:09
    一般情况下 ...计算一个半双工10M 接口的利用率时,你可以选择变量——使用MIB II(RFC2233)的变量或特定厂商提供的变量。在MIB II变量情形里,应用程序按照下列步骤人工计算百分比: 1. 计算iflnO
  • 应用服务器配置测算及计算公式

    万次阅读 2019-01-15 10:06:27
    应用服务器配置测算及计算公式 1 术语和定义 1.1 信息系统 由计算机、通信设备、处理设备、控制设备及其相关的配套设施构成,按照一定的应用目的和规则,对信息进行采集、加工、存储、传输、检索等处理的人机系统。...
  • 用户A与用户B通过卫星链路通信时,传播延迟为270ms,假设数据速率为64kb/s,帧长为4000bit,若采用停止等待ARQ协议通信,则最大链路利用率为(1);若采用退后N帧ARQ协议通信,发送窗口为8,则最大链路利用率可以达到...
  • EXPMA指标基础算法以及计算公式

    千次阅读 2017-03-15 23:01:54
    参考:ecpma指数-百度百科指标概述EXPMA...但这会使信号在时间上滞后,而EXPMA指标是对移动平均线的弥补,EXPMA指标由于其计算公式中着重考虑了价格当天(当期)行情的权重,因此在使用中可克服MACD其他指标信号对于
  • CPU的利用率是怎么计算

    千次阅读 2015-01-16 14:51:16
    分类: ...方法1: 使用CPU的处理能力基准计算实时CPU占用  ...(1) 在RTOS系统启动前, 使用Tick中断测试CPU的处理能力基准 CPUPerformanceBase;...(2) 在系统进入运行后, 使用...(3) 周期地计算CPU占用, 并清除RTC
  • 系统平均负载(Load average)与CPU利用率

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

    千次阅读 2020-05-28 15:43:31
    平均无障碍时间=1/P 单利计算 利息=本金×利率×时间,即IR=P×i×n 终值F=P×(1+i×n) 复利计算 折现与折现系数 若n 年后能收入F 元,那么这些钱现在的价值(现值) 称为折现系数。 现值:对未来收入或支出的...
  • 并发用户数,吞吐量计算公式

    万次阅读 2018-02-25 14:30:11
    一、经典公式1: 一般来说,利用以下经验公式进行估算系统的平均并发用户数和峰值数据 1)平均并发用户数为 C = nL/T 2)并发用户数峰值 C‘ = C + 3*根号C C是平均并发用户数,n是login session的数量,L是...
  • QPS(TPS)=并发数/平均响应时间 QPS(TPS): 每秒钟request/事务 数量 并发数: 系统同时处理的request/事务数 响应时间: 一般取平均响应时间 最大线程数 Max number of threads=(MaxProcessMemory – JVM...
  • tps系统吞吐量计算公式

    千次阅读 2015-05-06 12:50:43
    PS:下面是性能测试的主要概念和计算公式,记录下:一.系统吞度量要素:一个系统的吞度量(承压能力)与request对CPU的消耗、外部接口、IO等等紧密关联。单个reqeust 对CPU消耗越高,外部系统接口、IO影响速度越慢...
  • 性能指标及相关计算公式

    千次阅读 2019-03-25 14:50:07
    1.吞吐量 吞吐量是指单位时间内处理...通常在没有遇到性能瓶颈时,吞吐量可以采用下面公式计算: F=(N*R)/T F表示吞吐量;N表示并发虚拟用户数;R表示每个虚拟用户发出的请求数量,T表示性能测试所用的时间。 ...
  • 根据对应原理,得到了类氢原子能态平均寿命半经典的计算公式τ(n,l),然后利用相对论单通道量子数亏损理论进行推广,得到用来计算考虑总角动量J的激发态寿命公式τ(n,l,l+1/2和τ(n,l,l-1/2),利用单通道量子数亏损理论...
  • 网络工程师常用计算公式汇总

    千次阅读 2013-10-23 21:39:11
    计算总线数据传输速率  总线数据传输速率=时钟频率(Mhz)/每个总线包含的时钟周期数*每个总线周期传送的字节数(b)  计算系统速度  每秒指令数=时钟频率/每个总线包含时钟周期数/指令平均占用总线周期数  平均...
  • 计算机组成原理重点总结(学习笔记)含计算公式

    千次阅读 多人点赞 2020-07-24 17:55:05
    地址结构: 主存字块标记 字块内地址 优点:灵活,命中率高,缩小了块冲突率,空间利用率高。 缺点:地址变换速度慢,实现成本高 (3)组相联映射(上述两种映射的折中) 将Cache空间分成大小相同的组,主存的一个...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 46,282
精华内容 18,512
关键字:

平均利用率计算公式