精华内容
下载资源
问答
  • 如不清楚吞吐率(RPS)、平均响应时间、99%响应时间的概念请参考:性能测试的几个指标(并发数、吞吐率、响应时间、平均响应时间、99%响应时间) 1、原生Redis的两种主要性能测试指标 在原生的Redis benchm...

    这篇文章总结的是Redis的benchmark源码修改中增加一些性能测试指标所应思考的问题,以及解决问题的方法,权当本渣渣一篇笔记,如果您发现有疏漏错误之处,烦请留言指出!

    如不清楚吞吐率(RPS)、平均响应时间、99%响应时间的概念请参考:性能测试的几个指标(并发数、吞吐率、响应时间、平均响应时间、99%响应时间)

    1、原生Redis的两种主要性能测试指标

    在原生的Redis benchmark性能测试中,只提供了两种主要的测试指标:

    一是RPS(requests per second),即每秒完成的请求数量,反映的是服务器处理请求的吞吐率,这是redis最主要的性能测试指标。

    二是,当你不使用quiet模式输出(不使用-q参数)时,redis会展示出响应时间低于1ms、2ms、3ms...等的请求数占总请求数的百分比。如下图所示。

    下面我们分别说明以上两种测试指标的实现方式:

    首先我们需要知道benchmark.c文件的一个重要的数据结构static struct config。

    本文所讲的性能测试指标的最红显示和实现都是在redis-benchmark.c文件中的showLatencyReport函数中实现,所有修改也都在此函数中进行。

    static struct config {
        aeEventLoop *el;
        const char *hostip;
        int hostport;
        const char *hostsocket;
        int numclients;
        int liveclients;
        int requests;//总请求数
        int requests_issued;
        int requests_finished;//已完成的请求数
        int keysize;
        int datasize;
        int randomkeys;//1表示key值随机化
        int randomkeys_keyspacelen;//key值取0~该值中的随机数
        int keepalive;
        int pipeline;
        int showerrors;
        long long start;//性能测试前记录开始时间
        long long totlatency;//记录性能测试所用的总延时
        long long *latency;//算是一个数组指针,在堆空间开辟,存放每一笔请求的延时,一共有config.requests个
        const char *title;
        list *clients;
        int quiet;
        int csv;
        int loop;
        int idlemode;
        int dbnum;
        sds dbnumstr;
        char *tests;
        char *auth;
    } config;

    主要关注requests、 start、totlatency、*latency!

    (1)RPS的实现:总请求数 / 性能测试的总延时, 即 

    reqpersec = (float)config.requests_finished/((float)config.totlatency/1000);

    (2)响应时间低于1ms、2ms、3ms...等的请求数占总请求数的百分比实现:先对latency数组中的所有请求的响应时间进行从小到大排序,然后遍历,当遍历到响应时间低于1ms时计算响应百分比即可,以此类推。

    原生Redis实现的代码如下(以上两种指标的实现)

    //定义比较函数
    static int compareLatency(const void *a, const void *b) {
        return (*(long long*)a)-(*(long long*)b);
    }
    
    static void showLatencyReport(void) {
        int i, curlat = 0;
        float perc, reqpersec;
    
        reqpersec = (float)config.requests_finished/((float)config.totlatency/1000);
        if (!config.quiet && !config.csv) {
            printf("====== %s ======\n", config.title);
            printf("  %d requests completed in %.2f seconds\n", config.requests_finished,
                (float)config.totlatency/1000);
            printf("  %d parallel clients\n", config.numclients);
            printf("  %d bytes payload\n", config.datasize);
            printf("  keep alive: %d\n", config.keepalive);
            printf("\n");
    
            qsort(config.latency,config.requests,sizeof(long long),compareLatency);//对每条请求的响应时间进行升序排序
            for (i = 0; i < config.requests; i++) {//打印出低于1ms、2ms...等的请求数与总请求数的百分比
                if (config.latency[i]/1000 != curlat || i == (config.requests-1)) {
                    curlat = config.latency[i]/1000;
                    perc = ((float)(i+1)*100)/config.requests;
                    printf("%.2f%% <= %d milliseconds\n", perc, curlat);
                }
            }
            printf("%.2f requests per second\n\n", reqpersec);//打印rps
        } else if (config.csv) {
            printf("\"%s\",\"%.2f\"\n", config.title, reqpersec);
        } else {
        	printf("%s: %.2f requests per second\n", config.title, reqpersec);
    }

    2、添加平均响应时间、99%响应时间

    平均响应时间的实现

    平均响应时间=总响应时间÷总请求数, 公式很简单,但是我们深入思考会发现一些问题:刚开始时我把总响应时间误以为就是上面的totlatency,后来发现不对,这里说清楚区别:

    totlatency是在benchmark测试前后做的一个时间记录差值,即相当于服务器处理完requests条请求所花费的时间,这里面也包含了一部分客户端的函数执行的时间开销(我测试时使用单个客户端连接(即只有一个并发连接)、不使用管道pipelining的时候,测试出来的totlatency是大于【把latency数组中所有请求的响应时间相加所得sum】)。

    所以把latency数组中所有请求的响应时间相加所得sum(我们姑且称之为响应时间之和),跟延迟差值totlatency是不一样的!

    响应时间之和是所有请求的响应时间加到一块,而totlatency只是测试开始前后的一个时间差!但是你千万别以为响应时间之和就应该小于或者等于totlatency(因为你在测试过程中也有客户端的一些函数时间执行开销),我刚开始就是这样认为的!这种情况仅仅是当只有一个并发连接,并且不使用pipeline的时候,它确实是这样的!

    当不止一个并发连接的时候,客户端怎么操作的呢? 假如说有10个并发连接客户端,那么这十个客户端就会逐个发送请求,哪个客户端收到请求回复了就再接着发请求,一直到请求数全部得到回复。这里模拟的是10个客户端并发连接请求的情况。所以这样你会发现:最后算的响应时间之和是远远大于totlatency的!

    当使用pipelining的时候呢?假如-P的参数是5,即一条管道可以一次放5条请求。使用管道其实就是每次客户端把5个请求打包到一起然后一块发给服务器进行处理,服务器处理完之后把五个请求的结果再打包到一起返回给客户端。所以五条请求的响应时间是一样的!那这个时候五条请求的响应时间之和怎么算呢?是五个请求的响应时间全加起来,还是只算一个响应时间呢? 自习想一样,应该是把5个请求看做一个整体,他们的响应时间之和就是其中一个的响应时间。为什么这样算呢?很明显人家五个一起花了5ms,你不能说人家五个一共花了25ms吧! 比如说5个人团购一张券吃饭花了5块,那么每个人实质上是只用了1块,五个人一共用5块,而不是25块。所以当我们使用管道的时候,求平均响应时间和99%响应时间的时候需要整体除以管道大小pipeline。

    99%响应时间的实现

    先排序,然后找到99%所在的位置,把对应位置的响应时间记录即可。

    修改后的实现代码

    static void showLatencyReport(void) {
        int i, curlat = 0;
        float perc, reqpersec;
    
        reqpersec = (float)config.requests_finished/((float)config.totlatency/1000);
        if (!config.quiet && !config.csv) {
            printf("====== %s ======\n", config.title);
            printf("  %d requests completed in %.2f seconds\n", config.requests_finished,
                (float)config.totlatency/1000);
            printf("  %d parallel clients\n", config.numclients);
            printf("  %d bytes payload\n", config.datasize);
            printf("  keep alive: %d\n", config.keepalive);
            printf("\n");
    
            qsort(config.latency,config.requests,sizeof(long long),compareLatency);//对每条请求的响应时间进行升序排序
    		long long sumLatency = 0;//响应时间之和
    	    float avg, percentile99 = (float)config.latency[config.requests - 1]/1000;//平均响应时间、99%响应时间(初始化为最后一个请求的延迟),单位ms
    		int flag = 0;//临时辅助标志位
            for (i = 0; i < config.requests; i++) {
    			sumLatency += config.latency[i];//requests条命令的响应时间总和
    			if(flag == 0 && (float)(i + 1)/config.requests >= (float)0.99) { 
    				percentile99 = (float)config.latency[i]/1000;//99%响应时间
    				flag = 1;
    			}
                if (config.latency[i]/1000 != curlat || i == (config.requests-1)) {//打印出低于1ms、2ms...等的请求数与总请求数的百分比
                    curlat = config.latency[i]/1000;
                    perc = ((float)(i+1)*100)/config.requests;
                    printf("%.2f%% <= %d milliseconds\n", perc, curlat);
                }
            }
    		avg = (float)sumLatency/((float)config.requests*1000);//requests条请求的平均响应时间,单位是ms
    		if(config.pipeline > 1) {//考虑使用管道的特殊情况
    			avg /= config.pipeline;
    			percentile99 /= config.pipeline;
    		}
    		//printf("总延迟: %lldms  响应时间之和: %lldms\n", config.totlatency, sumLatency/1000);
            printf("%.2f requests per second | average response time: %.2fms | 99%%response time: %.2fms \n\n", reqpersec, avg, percentile99);
        } else if (config.csv) {
            printf("\"%s\",\"%.2f\"\n", config.title, reqpersec);
        } else {
        	printf("%s: %.2f requests per second\n", config.title, reqpersec);
        }
    }

     

     

     

     

     

    展开全文
  • 滤波器的截止频率是怎么影响信号的响应时间

      以下内容是关于模拟信号,传感器输出数字量的请上滑,输出模拟量的请放心食用!所以输出模拟量传感器的优势在哪里(我理解的输出数字量的数据是将采样的过程封装到了传感器里面,并输出数字量信号)?敲黑板:此处的响应时间并非时间常数。,具体可以查看图2中 τ R \tau_{\mathrm{R}} τR的定义。

    一、传感器的响应时间

      以温度传感器和气压传感器为例,文档中要求的动态响应如图1所示。其中温度传感器的时间常数是 τ 1 ≤ 2.5 s \tau{1} \leq 2.5 \mathrm{s} τ12.5s,气压传感器的时间常数是 τ 2 ≤ 0.08 s \tau{2} \leq 0.08 \mathrm{s} τ20.08s
      传感器的响应时间的定义如下:假设某信号从0上升到最大值MAX,信号一共变化了MAX,那么从0.1MAX0.9MAX的时间即为该传感器的响应时间,如果信号是下降的同理。其中信号上升时间即时间常数τ与带宽BW的关系公式是 B W = 0.35 / τ \mathrm{BW}=0.35 / \tau BW=0.35/τ。根据公式我们可以得到此信号带宽BW的最大值,为了保证信号通过滤波器不会影响该信号响应的快慢。所以滤波器的时间常数应该 ≤ \leq τ 1 \tau{1} τ1 ≤ \leq τ 2 \tau{2} τ2。根据公式滤波器的带宽应该 ≥ \geq 0.35 / τ 1 0.35 / \tau{1} 0.35/τ1 ≥ \geq 0.35 / τ 2 0.35 / \tau{2} 0.35/τ2

      在示波器探头参数中,也有关于其上升时间(即时间常数)与示波器信号带宽的公式,和上面公式一致即:上升时间=0.35/带宽。其中示波器探头上升时间的定义为:从最终值的0.1上升到最终值的0.9所需要的时间。示波器的上升时间是示波器理论上可以显示的最快的瞬变的时间。

    在这里插入图片描述

    图1 传感器的动态响应时间

    二、传感器响应时间与滤波器截止频率的关系

      传感器响应时间与滤波器截止频率的本质关系是求信号带宽信号与上升时间的关系,信号的带宽会影响后一级滤波器的截止频率。如果信号的上升边沿很陡峭,上升时间很短,那么该信号的带宽就很宽;上升时间越短,信号的带宽越宽。

    2.1、信号的带宽计算公式

      通常为了提高传感器信号的准确测量,不仅需要对信号进行放大到ADC的量程范围最大化使用ADC的性能,还要对信号进行输入滤波和输出滤波,此时滤波器的截止频率和响应时间密切相关。如果某信号的上升时间不大于t,即小于等于t,那么该信号的带宽不会大于0.35/t,为了保证滤波器既可以滤除高频干扰,又可以不影响该信号的传输,所以滤波器的截止频率应该大于该信号的带宽,那么0.35/t将会是你设计滤波器时的重要参考。

      上面我们已经知道了信号的最大带宽,或者说最大频率,我们以无源滤波器为例,理论分析时间常数为1的信号通过不同截止频率的滤波器后的输出会是什么样子的?首先我们关注信号的幅度变化,其次通过滤波器前后的FFT变化,以及通过滤波器前后的响应时间有无变化,因为这个是传感器的一个重要参数,我们增加的滤波电路是不能影响处理后信号的响应时间。

    2.2、0.35是怎么来的

      假设系统是一阶,根据RC滤波器的截止频率公式, f = 1 / 2 π R C \mathrm{f}=1 / 2 \pi \mathrm{RC} f=1/2πRC。传感器响应时间的定义:假设从0.1MAX到0.9MAX需要X个时间常数,上升时间=XRC,RC=上升时间/X,代入前面公式 f = 1 / 2 π R C \mathrm{f}=1 / 2 \pi \mathrm{RC} f=1/2πRC,那么 X / 2 π = 0.35 X / 2 \pi=0.35 X/2π=0.35 X = 0.7 π ≈ 2.2 X=0.7 \pi \approx 2.2 X=0.7π2.2。其中时间常数定义为从0上升到1-1/e,RC充电曲线,后面补充根据RC充电公式推倒X是不是2.2,也就是上升时间需要2.2个时间常数。充电到0.9MAX需要约2.3RC,充电到0.1MAX需要约0.1RC。公式为 0.9 = 1 − e ( − t 1 / R C ) 0.9=1-e^{\left(-t_{1} / R C\right)} 0.9=1e(t1/RC),所以 t 1 = ln ⁡ ( 10 ) ⋅ R C t_{1}=\ln (10) \cdot R C t1=ln(10)RC,可以求得t1=2.303RC,当上升到0.1MAX,公式 0.1 = 1 − e ( − t 2 / R C ) 0.1=1-e^{\left(-t_{2} / R C\right)} 0.1=1e(t2/RC),所以 t 2 = ln ⁡ ( 10 / 9 ) ⋅ R C t_{2}=\ln (10 / 9) \cdot R C t2=ln(10/9)RC,可以求得t2=0.105RCt1-t2就是2.2RC
      今天查看《模拟工程师口袋参考书》这本书的“小信号阶跃响应”这一章节也看到了“0.35”这个参数。书籍下载链接:模拟工程师口袋参考书

    图2 “0.35”相关资料

    2.3、RC充电时间常数

      其定义为:电容器的充电时间常数,当电容上的初始电压为0时,是电容的端电压达到最大值的0.63倍时所需要的时间记为 t c t_{c} tc,通常认为时间达到5倍的充电时间常数后就认为充满了,即 t = 5 t c t=5 t_{c} t=5tc,查看图3可以看到已经充电至99%或者掉电至1%。充电时间常数的大小与电路的电阻有关,按照下式计算: t c = R C t_{c}=R C tc=RC,其中R是电阻;C是电容,下图来自百度百科-电容
      假设有电源Vu通过电阻R给电容C充电,V0为电容上的初始电压值,Vu为电容充满电后的电压值,Vt为任意时刻t时电容上的电压值,那么便可以得到如下的计算公式: V t = V 0 + ( V u − V 0 ) ⋅ [ 1 − e ( − t / R C ) ] V_{t}=\mathrm{V}_{0}+\left(V_{u}-V_{0}\right) \cdot\left[1-e^{(-t / R C)}\right] Vt=V0+(VuV0)[1e(t/RC)]。当电容上的初始电压为0,则公式可以简化为 V t = V u ⋅ [ 1 − e ( − t / R C ) ] V_{t}=\mathrm{V}_{u} \cdot\left[1-e^{(-t / R C)}\right] Vt=Vu[1e(t/RC)],此时充电时间t与电压Vt的关系如表1所示,可以认为在3~5个时间常数后就充满了。当t=RC时, V t = V u ⋅ [ 1 − e ( − 1 ) ] V_{t}=\mathrm{V}_{u} \cdot\left[1-e^{(-1)}\right] Vt=Vu[1e(1)],其中 1 − e − 1 1-e^{-1} 1e1就是0.63,e≈2.7182818,大约等于2.72

    图3 电容的充放电曲线
    充电时间t电压Vt
    t=RCVt=0.63Vu
    t=2RCVt=0.86Vu
    t=3RCVt=0.95Vu
    t=4RCVt=0.98Vu
    t=5RCVt=0.99Vu
    表1 电容充电时间t时的电压Vt

    三、Multisim仿真

    3.1、信号的带宽

      使用Multisim作为仿真软件,PULSE_VOLTAGE用来模拟传感器的输出,使用RC构造无源低通滤波器作为滤波电路(因为在放大电路的前后使用了低通滤波器作为输入和输出滤波)。其中PULSE_VOLTAGE的波形如图4所示,是一个先上升后下降的三角波,上升时间和下降时间均是1ms,三角波的周期是1ms,RC无源滤波电路的截止频率满足公式: 1 / 2 π R C 1 / 2 \pi R C 1/2πRC。对于PULSE_VOLTAGE,因为上升时间和下降时间均是1ms,可以认为其时间常数等于0.8ms,那么其带宽则是437.5Hz

    在这里插入图片描述

    图4 响应时间与滤波器的Multisim仿真

    3.2、RC低通滤波器的截止频率

      RC低通滤波器的截止频率满足公式 f c = 1 2 π R C f_{c}=\frac{1}{2 \pi R C} fc=2πRC1。通过改变电容值,改变滤波器的截止频率,选取电容值为10nF、100nF、1000nF,可以设置滤波器的截止频率为过高、合适、过低。

    电容值截止频率
    10nF15914Hz
    100nF1591.4Hz
    1000nF159.14Hz

    3.3、仿真结果-波形对比

    在这里插入图片描述

    图5 仿真结果

    四、总结

       B W = 0.35 / τ \mathrm{BW}=0.35 / \tau BW=0.35/τ是对信号处理时设计滤波器时的重要参考,但是在设计完毕后,实测信号通过滤波器后是否满足要求才是最重要的。

    • 截止频率过低
        如果截止频率过低,那么变化太快的信号是不能通过滤波器的,可以发现三角波几乎已经变成正弦波,并且幅度也衰减了很多。
    • 截止频率过高
        截止频率远大于信号带宽,信号通过滤波器几乎不会变化,但是截止频率过高就丧失了滤波器的作用,不能滤掉无效高频信号,仿真的时候为了更加真实可以增加一个高频信号源用以模拟高频噪声。
    • 合适的截止频率
        设置合适的截止频率,不仅可以保证通过滤波器后的信号的响应时间常数满足要求,并且可以滤掉高频噪声。因为信号的带宽BW=437.5Hz,并且截止频率是-3dB点,所以不能设置437.5Hz为滤波器的截止频率,因为幅度会衰减为原来的 1 / 2 1 / \sqrt{2} 1/2 。设置滤波器的截止频率为1591.4Hz,可以保证437.5Hz处于滤波器的平坦带。输出的信号在顶部和顶部变平缓的原因是并不是理想的滤波器,如图6所示,从50Hz~fc,其衰减幅度是越来越大的从0dB到-3dB,通过设置坐标轴范围[红色方框所示],可以观察到[黄色圈的部分]不是垂直向下而是一个缓慢变化的曲线。
    图6 滤波器的幅频特性
    展开全文
  •  并发数是指在同一个时间点,同时请求服务的客户数量。  比如大家常说的:『 我的网站可以承受一万并发。 』在通常情况下指的是:如果同时有一万名用户访问网站,所有人都可以正常获得服务。而不会有超时或连接...

    并发数

      并发数是指在同一个时间点,同时请求服务的客户数量。

      比如大家常说的:『 我的网站可以承受一万并发。 』在通常情况下指的是:如果同时有一万名用户访问网站,所有人都可以正常获得服务。而不会有超时或连接拒绝情况发生。

    吞吐率

      吞吐率指的是服务处理请求的效率,计算方式为 ( 总处理请求数 / 总耗时 )。

      HTTP 服务的吞吐率通常以 RPS(Requests Per Second 请求数每秒)作为单位。吞吐量越高,代表服务处理效率就越高。换句话说就是网站的性能越高。

      注意:吞吐率和并发数是两个完全独立的概念。拿银行柜台来举个例子,并发数指同时有多少人往银行柜台涌来。吞吐率则指银行柜台在一段时间内可以服务多少个人。

      但是在性能测试中,二者之间通常会呈现出一种关联关系。当并发数增大时,吞吐率通常也会随之上升( 多用户发挥出并行处理优势) 。但在并发数超过某个边界值后,吞吐率则会下降 (用户过多,花在上下文切换的开销急剧增大,又或者内存消耗过多)。

    响应时间

      响应时间指的是用户从发出请求到接收完响应之间的总耗时,它由网络传输耗时、服务处理耗时等多个部分组成。通常以毫秒(ms)作为单位。

      与并发数的关系:一般来说,随着并发数增大,单个用户的响应时间通常会随之增加。这很好理解,餐馆吃饭的人越多,单个顾客等待的时间就越长。

      与吞吐率的关系:更高的吞吐率通常意味着更低的响应时间。因为吞吐率是以 单位时间 内的请求处理能力来计算的。

    平均响应时间与百分位响应时间

      平均响应时间指的是所有请求平均花费的时间,如果有100个请求,其中 98 个耗时为 1ms,其他两个为 100ms。那么平均响应时间为 (98 * 1 + 2 * 100) / 100.0 = 2.98ms 。

      百分位数( Percentile - Wikipedia )是一个统计学名词。以响应时间为例, 99% 的百分位响应时间 ,指的是 99% 的请求响应时间,都处在这个值以下。

      拿上面的响应时间来说,其整体平均响应时间虽然为 2.98ms,但 99% 的百分位响应时间却是 100ms。

      相对于平均响应时间来说,百分位响应时间通常更能反映服务的整体效率。现实世界中用的较多的是 98% 的百分位响应时间,比如 GitHub System Status 中就有一条 98TH PERC. WEB RESPONSE TIME 曲线。

    平均响应时间: 所有请求的平均响应时间,取的平均值
    95%percentile : 统计学术语,如果将一组数据从小到大排序,并计算相应的累计百分位,则某一百分位所对应数据的值就称为这一百分位的百分位数。可表示为:一组n个观测值按数值大小排列。如,处于p%位置的值称第p百分位数。

    例如有100个请求, 每个请求的响应时间分别是 1-100 平均分布
    平均响应时间: 1-100 的平均值,即 50.5 
    95% percentile : 按从小到大排序,累计第95百分位,也就是 95 (即样本里95% 的数据都不高于这个值)

     

    展开全文
  • Python Requests库 获取接口响应时间

    千次阅读 2019-10-10 19:38:13
    使用elapsed获取响应时间 1、elapsed介绍 官方文档:http://cn.python-requests.org/zh_CN/latest/api.html?highlight=elapsed#requests.Response.elapsed 查看帮助: import requests test = requests.get('...

    使用elapsed获取响应时间

    1、elapsed介绍

    官方文档:http://cn.python-requests.org/zh_CN/latest/api.html?highlight=elapsed#requests.Response.elapsed

    • 查看帮助:
    import requests
    
    test = requests.get('https://www.qq.com')
    
    print(help(test.elapsed))       # 查看帮助
    
    • 结果显示:
    Help on timedelta object:
    
    class timedelta(builtins.object)
     |  Difference between two datetime values.
     |  
     |  timedelta(days=0, seconds=0, microseconds=0, milliseconds=0, minutes=0, hours=0, weeks=0)
     |  
     |  All arguments are optional and default to 0.
     |  Arguments may be integers or floats, and may be positive or negative.
     |  
     |  Methods defined here:
     |  
     |  __abs__(self, /)
     |      abs(self)
     |  
     |  __add__(self, value, /)
     |      Return self+value.
     |  
     |  __bool__(self, /)
     |      self != 0
     |  
     |  __divmod__(self, value, /)
     |      Return divmod(self, value).
     |  
     |  __eq__(self, value, /)
     |      Return self==value.
     |  
     |  __floordiv__(self, value, /)
     |      Return self//value.
     |  
     |  __ge__(self, value, /)
     |      Return self>=value.
     |  
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |  
     |  __gt__(self, value, /)
     |      Return self>value.
     |  
     |  __hash__(self, /)
     |      Return hash(self).
     |  
     |  __le__(self, value, /)
     |      Return self<=value.
     |  
     |  __lt__(self, value, /)
     |      Return self<value.
     |  
     |  __mod__(self, value, /)
     |      Return self%value.
     |  
     |  __mul__(self, value, /)
     |      Return self*value.
     |  
     |  __ne__(self, value, /)
     |      Return self!=value.
     |  
     |  __neg__(self, /)
     |      -self
     |  
     |  __pos__(self, /)
     |      +self
     |  
     |  __radd__(self, value, /)
     |      Return value+self.
     |  
     |  __rdivmod__(self, value, /)
     |      Return divmod(value, self).
     |  
     |  __reduce__(...)
     |      __reduce__() -> (cls, state)
     |  
     |  __repr__(self, /)
     |      Return repr(self).
     |  
     |  __rfloordiv__(self, value, /)
     |      Return value//self.
     |  
     |  __rmod__(self, value, /)
     |      Return value%self.
     |  
     |  __rmul__(self, value, /)
     |      Return value*self.
     |  
     |  __rsub__(self, value, /)
     |      Return value-self.
     |  
     |  __rtruediv__(self, value, /)
     |      Return value/self.
     |  
     |  __str__(self, /)
     |      Return str(self).
     |  
     |  __sub__(self, value, /)
     |      Return self-value.
     |  
     |  __truediv__(self, value, /)
     |      Return self/value.
     |  
     |  total_seconds(...)
     |      Total seconds in the duration.
     |  
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |  
     |  __new__(*args, **kwargs) from builtins.type
     |      Create and return a new object.  See help(type) for accurate signature.
     |  
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |  
     |  days
     |      Number of days.
     |  
     |  microseconds
     |      Number of microseconds (>= 0 and less than 1 second).
     |  
     |  seconds
     |      Number of seconds (>= 0 and less than 1 day).
     |  
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |  
     |  max = datetime.timedelta(days=999999999, seconds=86399, microseconds=9...
     |  
     |  min = datetime.timedelta(days=-999999999)
     |  
     |  resolution = datetime.timedelta(microseconds=1)
    
    
    • 内置方法介绍
    import requests
    
    test = requests.get('https://www.qq.com')
    
    help(test.elapsed)
    print(test.elapsed.seconds)
    print(test.elapsed.days)
    print(test.elapsed.min)
    print(test.elapsed.max)
    print(test.elapsed.total_seconds())
    print(test.elapsed.microseconds)
    print(test.elapsed.resolution)
    
    返回结果:
    0
    0
    -999999999 days, 0:00:00
    999999999 days, 23:59:59.999999
    0.071056
    71056
    0:00:00.000001
    
    
    • 总结
      网上提出获取接口响应时间均为:test.elapsed.microseconds/(1000*1000),但是该种方式有个缺点(当接口的响应时间大于1s时,仅会截取后面的小数位)
      所以推荐使用:test.elapsed.total_seconds(),准确性较高,单位为s

    注:1 秒(second)[s] = 1000 毫秒millisecond[ms] = 1000000 微秒microsecond[us]


    展开全文
  • 响应时间过长问题分析

    万次阅读 2019-07-18 16:29:49
    响应时间是性能评估的一个重要指标,会对最终用户产生直接影响,一个产品是快是慢,响应时间是最直观的感受。 因此面对响应时间长的问题,一定想尽办法消灭它。 以下定位方法是针对比较典型的nginx+tomcat应用架构。...
  • 某saas应用,在请求一个接口的时候,发现响应时间非常的慢,利用前台google浏览器的F12调试,发现响应时间超过2秒 二、问题排查 项目整体采用前后端分离,前端通过nginx实现负载转发,请求后端接口,所以首先排查...
  • 性能测试必知——响应时间

    千次阅读 2019-08-09 21:05:39
    在上一节中,我们讲到吞吐量,做为一个用户你可以对吞吐量毫不关心,但响应时间却是用户感受系统性能的主要体现。 从用户角度来说,软件性能就是软件对用户操作的响应时间。说得更明确一点,对用户来说,当用户单击...
  • APP响应时间和响应速度测试

    千次阅读 2020-06-28 18:11:47
    测试点:APP启动相应时间和相应速度测试 冷启动:首次启动App的时间间隔,不包括页面加载,只是启动时间。 热启动:非首次启动App额时间间隔,不包括页面加载,只是启动时间。 测试方法: 冷启动: adb shell ...
  • LoadRunner中的时间处理- 响应时间、事务时间、消耗时间等 事务概念 在LoadRunner中,事务是指用户在客户端做一种或多种业务所需要的操作集(actions),通过事务开始和结束函数可以标记完成该业务所需要的操作内容...
  • 对于loadrunner而言,response time只反映了传输时间和系统处理事务的时间,而客户的浏览器从接收完所有字节开始到浏览器加载完所有... 通过Loadrunner获取的事务响应时间,主要可以分解为:First Buffer +Receive...
  • 高并发下如何缩短响应时间

    千次阅读 2019-12-25 21:48:50
    缩短一个网站响应时间真的很简单吗? 定义 网站响应时间是指系统对请求作出响应的时间。通俗来讲就是我们把网址输入进浏览器然后敲回车键开始一直到浏览器把网站的内容呈现给用户的这段时间。网站响应时间是越短越...
  • 什么是响应时间,并发数,吞吐量?

    万次阅读 多人点赞 2019-04-26 20:29:09
    **指应用执行一个操作所需的时间,...拿我们平常浏览网站点击链接为例,响应时间大致包括如下几步: 1. 用户通过鼠标或键盘发出请求操作 2. 浏览器构造请求(请求头,请求体) 3. 用户计算机向网站服务器发送HTTP请求
  • requests获取响应时间和超时

    千次阅读 2020-07-23 14:26:47
    requests获取响应时间与超时获取响应时间(elapsed)获取超时(timeout) 获取响应时间(elapsed) 关于requests库常用的的主要方法及参数,可以参照小鱼的这篇文章 requests库常用到的7个主要方法及控制访问参数 我们接...
  • postman响应时间 是一个线程或者一个用户再者说是发送一次请求的响应时间,一般都是200ms一下; 而jmeter属于并行,就是多个用户去访问这个功能点或者接口,多个用户同时访问,就会造成压力,自然而然。系统的响应...
  • TPS和事务响应时间的关系、计算公式

    万次阅读 多人点赞 2016-09-08 10:24:11
    例子:一个高速路有10个入口,每个入口每秒钟只能进1辆车 1、请问1秒钟最多能进几辆车?...每辆车的响应时间是多长?  TPS = 10,reponse time = 1 (10个为一等份,分成两等份,平均tps (10/1+10/2)/2=7.5 平均响应
  • 响应时间和吞吐量之间的关系

    万次阅读 2019-06-24 19:26:25
    响应时间的定义:响应时间是提交请求和返回该请求的响应之间使用的时间。 吞吐量的定义:吞吐量是对单位时间内完成的工作量的量度。 响应时间越短,单位时间内的吞吐量越大;响应时间越长,单位时间内的吞吐量越小...
  • 服务响应时间与分布(p99指标)

    千次阅读 2020-10-12 20:32:52
    分析服务响应时间分布,如:均值、中位值、P95值、P99值等如何计算 平均值 我们考察一个服务器的性能,除了QPS数据外,还会考察响应时间,当服务器负载增高时,往往会伴随着响应时间的增长,但是这个值该如何度量...
  • 使用curl命令查看请求响应时间方法

    千次阅读 2019-08-28 16:19:51
    curl命令查看请求响应时间 #curl-o/dev/null-s-w%{time_namelookup}::%{time_connect}::%{time_starttransfer}::%{time_total}::%{speed_download}"\n""http://www.36nu.com" 0.014::0.015::0.018::0.019::...
  • 网页响应时间测试标准是什么?

    万次阅读 2018-05-05 17:17:58
    1.响应时间 指的是客户发出请求...响应时间的计算模型:响应时间=网络传输时间(请求)+服务器处理时间(一层或是多层)+网络传输时间(响应)+页面前段解析时间简化的浏览器响应时间的计算模型:浏览器响应时间 =...
  • 进程调度新要求:响应时间

    千次阅读 2020-02-29 16:18:29
    响应时间 T响应时间= T首次运行- T到达时间 引入响应时间的原因:如果使用STCF的调度方式,可以使周转时间最短,但是,如果短任务很多,则没有长任务执行的机会,对长任务来说很“不公平” 轮转 轮转的思想:...
  • 响应时间的详解

    千次阅读 2019-07-03 10:22:00
    从下图可以看出,一个请求发出后,在没有缓存的情况下,需要经过网络传输、DNS解析等步骤才能...响应时间=网络传输(请求)时间+服务器处理(一层或多层)时间+网络传输(响应)时间+页面前端解析渲染时间。 ...
  • python requests获取服务器响应时间

    千次阅读 2021-03-05 14:28:35
    requests.get(url=url).elapsed.total_seconds() #时间为秒 可以获取从发起请求到服务器响应的时间 如,延时响应一秒,获取服务器响应时间 延时响应3秒,获取服务器响应时间
  • 网页与后台交互的响应时间设置

    千次阅读 2020-07-28 12:42:55
    在做项目的过程中,由于数据量巨大,导致后台计算时间较长,采用默认的交互参数往往导致响应超时,这时需要对前后端的请求时间和响应时间进行设置。
  • 关中断时间:指的是程序中有一些临界段代码(关于这个详细了解可以看我这篇文章,临界区,临界资源),需要关闭中断才能安全访问那么访问这段代码前关总中断,访问完后打开总中断,在这个时间内,系统是无法响应外部...
  • 伺服的采样周期:(对速度环、位置环而言,是对编码器采样,对电流环而言,是对霍尔元件或者电流互感器采样)、循环时间和响应时间均为伺服运动控制能力的指标。伺服循环时间:指PID计算循环时间,也是伺服设定值...
  • Nginx 配置请求响应时间

    千次阅读 2019-09-20 22:27:53
    指的就是从接受用户请求的第一个字节到发送完响应数据的时间,即包括接收请求数据时间、程序响应时间、输出 响应数据时间。 (2)upstream_response_time 官网描述:keeps times of responses obtained from upstream...
  • 响应时间:一般取平均响应时间 (很多人经常会把并发数和TPS理解混淆) 理解了上面三个要素的意义之后,就能推算出它们之间的关系: QPS(TPS)= 并发数/平均响应时间 并发数 = QPS*平均响应时间 ...
  • 性能测试——响应时间

    千次阅读 2019-05-12 18:52:51
    大部分资料都是说:“响应时间=网络响应时间+应用程序响应时间”诸如此类的解释,一时间让人摸不着头脑。 其实可以换个角度去理解这个概念。首先从大方向可以把一个系统分为【前端】与【后端】,而响应时间也可以...
  • 如何优化网站的响应时间

    千次阅读 2016-09-20 23:10:03
    一个网站能不能留住用户,除了要看网站的内容,另外一个重要因素就是网站的响应时间。如果网站的响应时间过长,很可能导致用户流失。因此,要经营好一个网站,就必须优化网站的响应时间,提高网站的响应速度。 ...
  • https://blog.csdn.net/senblingbling/article/details/43916851

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,231,154
精华内容 492,461
关键字:

响应时间