精华内容
下载资源
问答
  • TD-LTE上行吞吐率优化指导书V2.0

    千次阅读 2020-07-20 21:35:04
    TD-LTE上行吞吐率优化指导书 拟制: 广西LTE专项项目组 日期: 更新: 日期: 审核: 日期: 批准: 日期: 华为技术有限公司 版权所有 侵权必究 目录 1 指标定义和调度原理 2 1.1 指标定义 2 1.2 上行调度...

    产品名称 密级
    LTE 内部公开
    产品版本 共12页

    TD-LTE上行吞吐率优化指导书

    拟制: 广西LTE专项项目组 日期:
    更新: 日期:
    审核: 日期:
    批准: 日期:

    华为技术有限公司
    版权所有 侵权必究

    目录
    1 指标定义和调度原理 2
    1.1 指标定义 2
    1.2 上行调度基本过程 3
    2 影响上行吞吐率的基本因素 3
    2.1 系统带宽 3
    2.2 数据信道可用带宽 3
    2.3 UE能力限制 4
    2.4 上行单用户RB数分配限制 4
    2.5 信道条件 4
    问题的定位思路 5
    2.6 上行吞吐率根因分析全貌 5
    2.7 问题定位流程详述 6
    2.7.1 分配RB数少/UL Grant不足定位方法 6
    2.7.2 低阶MCS定位方法 7
    2.7.3 IBLER高问题定位方法 7
    2.7.4 覆盖问题定位方法 8
    3 典型案例 8
    3.1 上行达不到峰值 8
    3.1.1 问题描述 8
    3.1.2 问题分析 8
    3.1.3 解决措施 8

    1指标定义和调度原理
    1.1指标定义
    吞吐率定义:单位时间内下载或者上传的数据量。
    吞吐率公式:吞吐率=∑下载上传数据量/统计时长。
    上行吞吐率主要通过如下指标衡量,不同指标的观测方法一致,测试场景选择和限制条件有所不同:
    (1)上行单用户峰值吞吐率:上行单用户峰值吞吐率以近点静止测试,进行UDP/TCP灌包,使用RLC层平均吞吐率进行评价。需要记录下行RSRP、上行SINR、上行RLCThr、IBLER等信息。
    (2)上行单用户平均吞吐率:上行单用户平均吞吐率以移动测试时,进行UDP/TCP灌包,使用RLC层平均吞吐率曲线(吞吐率-PL曲线)进行评价。移动区域包含近点、中点、远点区域,移动速度最好30km/h以内。需要记录下行RSRP、上行SINR、上行RLCThr、IBLER等信息;RLC层平均吞吐率使用各点吞吐率地理平均结果。为便于问题定位,单用户平均吞吐率测试时,需要同时记录probe信息,以便从地理分布上找出异常点进行问题定位。
    (3)上行单用户边缘吞吐率:上行单用户边缘吞吐率是指移动测试,进行UDP/TCP灌包,对RLC吞吐率进行地理平均,以两种定义分别记录边缘吞吐率。
    定义1)以CDF曲线5%的点为边缘吞吐率;
    定义2)以PL为120定义为小区边缘,此时的吞吐率为边缘吞吐率;此处只定义RSRP边缘覆盖的场景,假定此时的干扰接近白噪声,此种场景类似于单小区测试。对于多个小区共同覆盖的干扰高风险边缘区域的定义,已经有运营商提出,在以后的文档版本更新完善。
    (4)上行小区峰值吞吐率:上行小区峰值吞吐率测试时,用户均在近点,采用UDP/TCP灌包,信道质量足以达到最高阶MCS,IBLER为0;通过小区级RLC平均吞吐率观测。测试步骤如下:
    a、用户近点接入,同时开始上行灌包。
    b、记录数据,包括每UE上行SINR、IBLER、Thr和Probe信息,以及上行小区吞吐率和RB利用率。
    (5)上行小区平均吞吐率:上行小区平均吞吐率测试时,用户分布一般类似1:2:1分布,即近点1UE、中点2UE、远点1UE,其中近点/中点/远点定义为RSRP-85dbm/-95dbm/-105dbm。采用UDP/TCP灌包。通过小区级RLC平均吞吐率观测;记录包括每UE上行SINR、IBLER、Thr和Probe信息,以及上行小区吞吐率和RB利用率。
    1.2上行调度基本过程

    在初始接入时,UE在PUCCH发送SR(调度请求),用来请求少量数据的上行资源调度。eNB侧根据实际资源情况和调度算法,给UE分配相应的上行资源,在PDCCH上下发ULGrant通知UE;在已有上行资源的情况下,UE在PUSCH发送BSR(缓冲区状态报告)进行上行资源调度请求;eNB侧在PDCCH上下发ULGrant通知UE。
    2影响上行吞吐率的基本因素
    2.1系统带宽
    系统的不同带宽决定了系统的总RB数

    2.2数据信道可用带宽
    公共信道的开销进一步决定了用户可以实际使用的资源,其中下行主要包括PDCCH和系统消息,上行主要包括PUCCH、SRS、PRACH.
    2.3UE能力限制
    在计算单用户峰值时,在考虑用户可用带宽时,还需要考虑UE能力的限制,不同类型UE具备不同的上下行峰值速率,且只有Cat5终端才支持上行64QAM;

    2.4上行单用户RB数分配限制
    在计算单用户的上行吞吐率时,还要考虑单用户分配的RB个数需满足一定条件。
    2.5信道条件
    信道条件主要包含RSRP,AVGSINR,信道相关性等参数,这些都会对实际的信号解调性能造成影响。如果RSRP过低,则可使用的有用信号的越低;如果AVGSINR过低,则干扰信号强度较有用信号越大;而信道相关性会对RANK值计算造成影响:一般MIMO模式要求信道相关性低,而BF模式则要求信道相关性高,这些都将对解调性能造成较大影响。
    3问题的定位思路
    3.1上行吞吐率根因分析全貌

    4.1-1 上行吞吐率低问题分析定位思路
    一般而言,吞吐率由频谱效率、频带宽度、频带占用机会、误码率综合决定。在LTE系统中,频谱效率由MCS决定,MCS由SINR和IBLER决定;频带宽度由分配的RB数决定;频带占用机会由UL grant决定;误码率主要考虑IBLER,HARQ重传以后,残留BLER通常较低,但由于重传会影响传输的效率,进而影响RLC层吞吐率,因此只考虑初次传输的BLER,也即IBLER。
    3.2问题定位流程详述
    3.2.1分配RB数少/UL Grant不足定位方法
    当发现RB数较少/UL grant低时,需要进行以下的判断动作:
    首先检查是否为DSP能力限制;通过IFTS跟踪观察上行DSP能力限制的RB数。
    观察核心网指配的QoS速率,如果偏低,则检查核心网开户信息是否异常;
    从L1 TTI跟踪中统计观察是否存在大量DTX情况,判断方法:观察上行DMRS RSRP,如果发现RSRP值在调度的TTI处于底噪(-120dbm)附近,或者与前后的RSRP值相差较大,则认为是上行PUSCH的DTX。对比eNB侧DCI0次数,如果相差较大,则认为存在大量的DTX,需要判断PDCCH质量问题,是否是下行PDCCH IBLER较高,导致UL Grant解错。说明:PDCCH允许一定的误检率,允许1%以内;而且上行HARQ时,调度器不需要下发ULGrant。
    观察是否数据源不足(上报BSR 对应的值),如果数据源不足,需要排查是否上层数据源异常,可能包括如下原因:(1)如果是UDP业务,检查上行灌包(出口速率)是否超过峰值速率。(2)如果是TCP单线程业务,尝试多个线程,如果吞吐量可以提升到峰值速率,则可以认定是PC机的TCP窗口没有符合要求。说明:如果ULGrant个数偏小,一般是由于上述两个原因导致。
    在性能检测中观察在线用户数,看是否存在多用户并行业务(2个以上)的情况,如果存在多用户,则主要观察RB利用率是否达到了100%,公平性是否得到满足。如果RB利用率低,则需要判断ICIC和频选是否开关打开,是否存在问题;如果公平性得不到满足,则可能为功控和ICIC的问题。这里的公平性指RB数公平,与算法的目标一致。
    检查PRACH的资源配置。上行预留PRACH的时候,会对上行分配RB产生影响,对上行峰值速率产生影响,10M系统更明显。可以将PRACH设置到PUSCH最低端,且将PRACH默认周期从5ms扩大为20ms。
    检查PUCCH配置,当前默认配置占用8RB,在单用户峰值测试时,可以手动改为2个RB,提高上行峰值吞吐率,再测极限峰值。
    3.2.2低阶MCS定位方法
    MCS由几方面决定:干扰、IBLER、UE CAT能力、是否扩展CP、下行PDCCH质量:
    在较高的上行SINR时,如果下行PDCCH质量太差,导致UL grant丢失,会导致IBLER较高;SINR调整算法模块,依据IBLER历史信息,对SINR测量值进行调整,输入到MCS选择模块,确保IBLER收敛于目标值。也就是说在PDCCH较差的情况下,可能存在上行SINR较好而MCS较低的情况。这种情况下通过查看上行测量SINR、SINR调整量、IBLER可以进行判断。如果某一段时间测量SINR比较高,而SINR调整量为负的较大值,而IBLER也超过门限值,则可能属于这种情况,需要进行PDCCH质量的问题进行分析。
    空载时(UE没有入网),打开LMT上小区性能检测中的干扰检测项,查看全带宽上RSSI(第101列)是否超过正常范围。以下为空载下,RSSI取值(底噪为-120dBm左右,全带宽为RSSI显示中第101列)
    BW RSSI
    20MHz -101dBm
    10MHz -104dbm
    5MHz -107dBm
    如果空载下,总RSSI明显大于上述值,需要确认是否存在干扰。可以查看不同RB上干扰状况(一般为-120波动)。特别注意观察中间频段RB上的RSSI是否比其他RB上高较多(RRU或者其他设备的直流干扰会抬升RSSI)。出现这种现象时请检查组网和UE RRU,通过扫频确定是否有窄带干扰,或者是UE设备异常。(说明:所谓中间频段是只RB序号在中间的RB,如20M带宽时,49和50RB;10M带宽时24和25RB。)
    判断是否由于终端能力限制,具体现象是MCS阶数最大只能达到24阶,这时进一步查看终端能力即可判断。
    是否扩展CP在算法中对应了不同的MCS选择表格,映射得到的MCS有区别,在非超远覆盖场景下,需保证设置为normal CP。
    3.2.3IBLER高问题定位方法
    查看空载RSSI是否有干扰(3.2.2所述),排除干扰问题;同时观察UE发射功率是否为最大,如果未达到最大,则可能为UE问题。
    在统计IBLER时,如果发生PDCCH质量差导致UL grant丢失,UE不发数据的情况,eNB会将该TTI作为CRC校验错处理,统计为误块,导致IBLER升高。
    当发现IBLER不收敛时,如果非MCS0,则需要判断SINR调整算法开关SW_SINR_ADJUST是否关闭,该开关关闭以后,导致MCS选择前的SINR调整量不能依据IBLER情况及时调整,MCS无法降低导致IBLER无法收敛;如果该开关打开,则检查调整量是否已经达到下限不能再下降从而导致MCS无法降低同时IBLER升高。
    3.2.4覆盖问题定位方法
    存在上行RSRP信号较弱导致上行吞吐率低情况,可查看UE发射功率是否达到最大,如果未达到最大,则可能为UE问题。如果UE发射功率已达到最大,可从链路损耗、覆盖范围、是否存在阻挡物或弱覆盖区域等原因进行处理。
    切换异常,一般指切换到不合理小区、切换不及时、切换频繁导致上行吞吐率低,需结合无线环境、配置参数进行处理。
    4典型案例
    4.1上行达不到峰值
    【问题描述】:小区近点上行吞吐率无法达到峰值。
    【问题分析】:上行单用户吞吐率达到峰值必须具备以下三个条件:
    MCS选择到最高28阶,BLER为0;这就要求SINR要高于20dB。
    UE分配到最多RBNum;
    数据源充足,ULGrant个数等于每s上行的子帧个数。
    因此,这个问题的定位需要从RBNum、MCS/SINR和ULGrant数目三个方面进行。
    确保MCS选择到最高阶。
    通过Probe查看上行MCS。Probe中的UL MCS显示栏中务必只显示MCS 28和MCS27,其中MCS28和MCS27的调度次数相加等于上行子帧个数表示调度数据充足,100个27阶是因为发送SRS时SRS子帧码率会增加,需要强制降阶(TDD在用户数较少的情况下,SRS在特殊子帧发数,就不会有降阶的问题)。如果ULGrant个数低于上行子帧个数,请检查数据源是否充足或者BSR上报周期是否合理(修改为5ms)。
    说明:MCS由两方面决定:SINR值和IBLER。P0决定了到达ENB的期望功率谱密度,直接影响SINR,进而影响MCS。如果上行SINR波动较大,导致有时BLER较高,SINR调整功能为保证IBLER收敛会降低MCS。
    查看SINR。从MCS定标测试结果看,48RB下,MCS28阶需要SINR在20dB以上。SINR低于20dB从以下几个方面定位:
    在Probe上查看UE发射功率是否达到最大23dBm。开环时,需确认P0是否配置合理值(基线偏=-67dBm,α=0.7)。如果发射功率没有达到最大,需要通过抬升P0抬升UE发射功率。
    如果上行SINR波动较大,查看是否是TA不准导致;是否是不断变化的干扰导致。可以将UE退网,观察RSSI。
    确保干扰 IOT在正常范围内。
    空载时(UE没有入网),打开LMT上小区性能检测中的干扰检测项,查看全带宽上RSSI(第101列)是否超过正常范围。以下为空载下,RSSI取值(底噪为-121dBm,全带宽为RSSI显示中第101列)
    BW RSSI
    20MHz -101dBm
    10MHz -104dbm
    5MHz -107dBm
    如果空载下,总RSSI明显大于上述值,需要确认是否存在干扰。可以查看不同RB上干扰状况(一般为-121波动)。特别注意观察中间频段RB上的RSSI是否比其他RB上高较多(RRU或者其他设备的直流干扰会抬升RSSI)。出现这种现象时请检查组网和UE RRU,或者联系RTT和中射频兄弟定位。(说明:所谓中间频段是只RB序号在中间的RB,如20M带宽时,49和50RB;10M带宽时24和25RB。)
    确保RB数目达到最大。
    查看UE分配RB数目有两种途径:UE侧Probe查看和eNB侧LMT跟踪
    通过Probe中Bandwith项监控查看:

    其中,左边一列表示RB数目,右边一列表示RB起始位置。如上图
    一是LMT中RB利用率监控项,单用户最大90RB,加上PUCCH 8个RB,应该显示98RB;
    如果RB数目不足,可能由以下几个原因:
    数据源不足。
    P0设置不合理。
    PRACH占用资源。
    确保ULGrant充足。
    可以通过查看Probe上的ULGrant个数确定。

    如果ULGrant小于上行子帧总数,则说明数据量不足或者PDCCH解错。可能由以下原因引起:
    (1)如果是UDP业务,检查上行灌包(出口速率)是否超过峰值速率。
    (2)如果是TCP单线程业务,尝试多个线程,如果吞吐量可以提升到峰值速率,则可以认定是业务电脑的TCP窗口没有符合要求,需要按照本文前述方法修改TCP默认发送窗口太小。
    说明:如果ULGrant个数不足,一般是由于上述两个原因导致。
    (3)是否是下行PDCCH BLER较高,导致UL Grant解错。需要修改PDCCH的CCE聚合级别。
    说明:PDCCH允许一定的误码率,默认是1%;而且上行HARQ时,调度器不需要下发ULGrant,所以在计算ULGrant个数时需要用上行子帧总数*0.9。
    (4)BSR上报问题。需要将BSR周期从32ms修改为5ms。
    4 通过修改PRACH位置和周期提高峰值速率。
    上行预留PRACH的时候,会对上行分配RB产生影响,对上行峰值速率产生影响,10M系统更明显。可以将PRACH设置到PUSCH最低端,且将PRACH默认周期从5ms扩大为20ms。
    5 通过修改PUCCH占用RB数目提高峰值速率。

    展开全文
  • 专注于分享4/5G网优资料:包括网络优化基础原理资料、各厂家常用网管指导、接入、切换、掉线、高丢包、干扰分析、速率、容量负载均衡、覆盖单验簇优化、各类网优常用工具合集
  • 专注于分享4/5G网优资料:包括网络优化基础原理资料、各厂家常用网管指导、接入、切换、掉线、高丢包、干扰分析、速率、容量负载均衡、覆盖单验簇优化、各类网优常用工具合集
  • Java高吞吐量系统设计优化建议

    千次阅读 2016-04-15 20:45:01
    吞吐量系统 举一个例子,我们做项目需要安排计划,每一个模块可以由多人同时并行做多项任务,也可以一个人或者多个人串行工作,但始终会有一条关键路径,这条路径就是项目的工期。系统一次调用的响应时间跟项目...

    高吞吐量系统

    举一个例子,我们做项目需要安排计划,每一个模块可以由多人同时并行做多项任务,也可以一个人或者多个人串行工作,但始终会有一条关键路径,这条路径就是项目的工期。系统一次调用的响应时间跟项目计划一样,也有一条关键路径,这个关键路径是就是系统影响时间。关键路径由 CPU 运算、IO、外部系统响应等等组成。

    对于一个系统的用户来说,从用户点击一个按钮、链接或发出一条指令开始,到系统把结果以用户希望的形式展现出来为终止,整个过程所消耗的时间是用户对这个软件性能的直观印象,也就是我们所说的响应时间。当响应时间较短时,用户体验是很好的,当然用户体验的响应时间包括个人主观因素和客观响应时间。在设计软件时,我们就需要考虑到如何更好地结合这两部分达到用户最佳的体验。如:用户在大数据量查询时,我们可以将先提取出来的数据展示给用户,在用户看的过程中继续进行数据检索,这时用户并不知道我们后台在做什么,用户关注的是用户操作的响应时间。

    我们经常说的一个系统吞吐量,通常由 QPS(TPS)、并发数两个因素决定,每套系统这两个值都有一个相对极限值,在应用场景访问压力下,只要某一项达到系统最高值,系统的吞吐量就上不去了,如果压力继续增大,系统的吞吐量反而会下降,原因是系统超负荷工作,上下文切换、内存等等其它消耗导致系统性能下降,决定系统响应时间要素。

    缓冲 (Buffer)

    缓冲区是一块特定的内存区域,开辟缓冲区的目的是通过缓解应用程序上下层之间的性能差异,提高系统的性能。在日常生活中,缓冲的一个典型应用是漏斗。缓冲可以协调上层组件和下层组件的性能差,当上层组件性能优于下层组件时,可以有效减少上层组件对下层组件的等待时间。基于这样的结构,上层应用组件不需要等待下层组件真实地接受全部数据,即可返回操作,加快了上层组件的处理速度,从而提升系统整体性能。

    使用 BufferedWriter 进行缓冲

    BufferedWriter 就是一个缓冲区用法,一般来说,缓冲区不宜过小,过小的缓冲区无法起到真正的缓冲作用,缓冲区也不宜过大,过大的缓冲区会浪费系统内存,增加 GC 负担。尽量在 I/O 组件内加入缓冲区,可以提高性能。一个缓冲区例子代码如清单 1 所示。

    清单 1. 加上缓冲区之前示例代码
    import java.awt.Color;
    import java.awt.Graphics;
    import java.awt.Graphics2D;
    import java.awt.Image;
    
    import javax.swing.JApplet;
    
    
    public class NoBufferMovingCircle extends JApplet implements Runnable{
     Image screenImage = null;
     Thread thread;
     int x = 5;
     int move = 1;
     
     public void init(){
     screenImage = createImage(230,160);
     }
     
     public void start(){
     if(thread == null){
     thread = new Thread(this);
     thread.start();
     }
     }
     
    @Override
    public void run() {
    // TODO Auto-generated method stub
    try{
    System.out.println(x);
    while(true){
    x+=move;
    System.out.println(x);
    if((x>105)||(x<5)){
    move*=-1;
    }
    repaint();
    Thread.sleep(10);
    }
    }catch(Exception e){
    
    }
    }
    
    public void drawCircle(Graphics gc){
    Graphics2D g = (Graphics2D) gc;
    g.setColor(Color.GREEN);
    g.fillRect(0, 0, 200, 100);
    g.setColor(Color.red);
    g.fillOval(x, 5, 90, 90);
    }
    
    public void paint(Graphics g){
    g.setColor(Color.white);
    g.fillRect(0, 0, 200, 100);
    drawCircle(g);
    }
    
    }

    程序可以完成红球的左右平移,但是效果较差,因为每次的界面刷新都涉及图片的重新绘制,这较为费时,因此,画面的抖动和白光效果明显。为了得到更优质的显示效果,可以为它加上缓冲区。代码如清单 2 所示。

    清单 2. 加上缓冲区之后示例代码
    import java.awt.Color;
    import java.awt.Graphics;
    
    
    public class BufferMovingCircle extends NoBufferMovingCircle{
     Graphics doubleBuffer = null;//缓冲区
     
     public void init(){
     super.init();
     doubleBuffer = screenImage.getGraphics();
     }
     
     public void paint(Graphics g){//使用缓冲区,优化原有的 paint 方法
     doubleBuffer.setColor(Color.white);//先在内存中画图
     doubleBuffer.fillRect(0, 0, 200, 100);
     drawCircle(doubleBuffer);
     g.drawImage(screenImage, 0, 0, this);
     }
    }

    使用 Buffer 进行 I/O 操作

    除 NIO 外,使用 Java 进行 I/O 操作有两种基本方式:

    • 使用基于 InputStream 和 OutputStream 的方式;
    • 使用 Writer 和 Reader。

    无论使用哪种方式进行文件 I/O,如果能合理地使用缓冲,就能有效地提高 I/O 的性能。

    下面显示了可与 InputStream、OutputStream、Writer 和 Reader 配套使用的缓冲组件。

    OutputStream-FileOutputStream-BufferedOutputStream

    InputStream-FileInputStream-BufferedInputStream

    Writer-FileWriter-BufferedWriter

    Reader-FileReader-BufferedReader

    使用缓冲组件对文件 I/O 进行包装,可以有效提高文件 I/O 的性能。

    清单 3. 示例代码
    import java.io.BufferedInputStream;
    import java.io.BufferedOutputStream;
    import java.io.DataInputStream;
    import java.io.DataOutputStream;
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    
    public class StreamVSBuffer {
     public static void streamMethod() throws IOException{
     try {
    long start = System.currentTimeMillis();
    //请替换成自己的文件
     DataOutputStream dos = new DataOutputStream(
                            new FileOutputStream("C:\\StreamVSBuffertest.txt"));
    for(int i=0;i<10000;i++){
    dos.writeBytes(String.valueOf(i)+"\r\n");//循环 1 万次写入数据
    }
    dos.close();
    DataInputStream dis = new DataInputStream(new FileInputStream("C:\\StreamVSBuffertest.txt"));
    while(dis.readLine() != null){
     
    }
    dis.close();
     System.out.println(System.currentTimeMillis() - start);
    } catch (FileNotFoundException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
    }
     
     }
     
     public static void bufferMethod() throws IOException{
     try {
     long start = System.currentTimeMillis();
     //请替换成自己的文件
     DataOutputStream dos = new DataOutputStream(new BufferedOutputStream(
                                            new FileOutputStream("C:\\StreamVSBuffertest.txt")));
     for(int i=0;i<10000;i++){
     dos.writeBytes(String.valueOf(i)+"\r\n");//循环 1 万次写入数据
     }
     dos.close();
     DataInputStream dis = new DataInputStream(new BufferedInputStream(
                                            new FileInputStream("C:\\StreamVSBuffertest.txt")));
     while(dis.readLine() != null){
     
     }
     dis.close();
     System.out.println(System.currentTimeMillis() - start);
     } catch (FileNotFoundException e) {
     // TODO Auto-generated catch block
     e.printStackTrace();
     }
     }
     
     public static void main(String[] args){
     try {
    StreamVSBuffer.streamMethod();
    StreamVSBuffer.bufferMethod();
    } catch (IOException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
    }
     }
    }

    运行结果如清单 4 所示。

    清单 4. 运行输出
    889
    31

    很明显使用缓冲的代码性能比没有使用缓冲的快了很多倍。清单 5 所示代码对 FileWriter 和 FileReader 进行了相似的测试。

    清单 5.FileWriter 和 FileReader 代码
    import java.io.BufferedInputStream;
    import java.io.BufferedOutputStream;
    import java.io.BufferedReader;
    import java.io.BufferedWriter;
    import java.io.FileNotFoundException;
    import java.io.FileReader;
    import java.io.FileWriter;
    import java.io.IOException;
    
    
    public class WriterVSBuffer {
     public static void streamMethod() throws IOException{
     try {
    long start = System.currentTimeMillis();
     FileWriter fw = new FileWriter("C:\\StreamVSBuffertest.txt");//请替换成自己的文件
    for(int i=0;i<10000;i++){
    fw.write(String.valueOf(i)+"\r\n");//循环 1 万次写入数据
    }
    fw.close();
    FileReader fr = new FileReader("C:\\StreamVSBuffertest.txt");
    while(fr.ready() != false){
     
    }
    fr.close();
     System.out.println(System.currentTimeMillis() - start);
    } catch (FileNotFoundException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
    }
     
     }
     
     public static void bufferMethod() throws IOException{
     try {
     long start = System.currentTimeMillis();
     BufferedWriter fw = new BufferedWriter(new FileWriter("C:\\StreamVSBuffertest.txt"));//请替换成自己的文件
     for(int i=0;i<10000;i++){
     fw.write(String.valueOf(i)+"\r\n");//循环 1 万次写入数据
     }
     fw.close();
     BufferedReader fr = new BufferedReader(new FileReader("C:\\StreamVSBuffertest.txt"));
     while(fr.ready() != false){
     
     }
     fr.close();
     System.out.println(System.currentTimeMillis() - start);
     } catch (FileNotFoundException e) {
     // TODO Auto-generated catch block
     e.printStackTrace();
     }
     }
     
     public static void main(String[] args){
     try {
    StreamVSBuffer.streamMethod();
    StreamVSBuffer.bufferMethod();
    } catch (IOException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
    }
     }
    }

    运行输出如清单 6 所示。

    清单 6. 运行输出
    1295
    31

    从上面例子可以看出,无论对于读取还是写入文件,适当地使用缓冲,可以有效地提升系统的文件读写性能,为用户减少响应时间。

    缓存

    缓存也是一块为提升系统性能而开辟的内存空间。缓存的主要作用是暂存数据处理结果,并提供下次访问使用。在很多场合,数据的处理或者数据获取可能会非常费时,当对这个数据的请求量很大时,频繁的数据处理会耗尽 CPU 资源。缓存的作用就是将这些来之不易的数据处理结果暂存起来,当有其他线程或者客户端需要查询相同的数据资源时,可以省略对这些数据的处理流程,而直接从缓存中获取处理结果,并立即返回给请求组件,以此提高系统的响应时间。

    目前有很多基于 Java 的缓存框架,比如 EHCache、OSCache 和 JBossCache 等。EHCache 缓存出自 Hibernate,是其默认的数据缓存解决方案;OSCache 缓存是有 OpenSymphony 设计的,它可以用于缓存任何对象,甚至是缓存部分 JSP 页面或者 HTTP 请求;JBossCache 是由 JBoss 开发、可用于 JBoss 集群间数据共享的缓存框架。

    以 EHCache 为例,EhCache 的主要特性有:

    1. 快速;
    2. 简单;
    3. 多种缓存策略;
    4. 缓存数据有两级:内存和磁盘,因此无需担心容量问题;
    5. 缓存数据会在虚拟机重启的过程中写入磁盘;
    6. 可以通过 RMI、可插入 API 等方式进行分布式缓存;
    7. 具有缓存和缓存管理器的侦听接口;
    8. 支持多缓存管理器实例,以及一个实例的多个缓存区域;
    9. 提供 Hibernate 的缓存实现。

    由于 EhCache 是进程中的缓存系统,一旦将应用部署在集群环境中,每一个节点维护各自的缓存数据,当某个节点对缓存数据进行更新,这些更新的数据无法在其它节点中共享,这不仅会降低节点运行的效率,而且会导致数据不同步的情况发生。例如某个网站采用 A、B 两个节点作为集群部署,当 A 节点的缓存更新后,而 B 节点缓存尚未更新就可能出现用户在浏览页面的时候,一会是更新后的数据,一会是尚未更新的数据,尽管我们也可以通过 Session Sticky 技术来将用户锁定在某个节点上,但对于一些交互性比较强或者是非 Web 方式的系统来说,Session Sticky 显然不太适合。所以就需要用到 EhCache 的集群解决方案。清单 7 所示是 EHCache 示例代码。

    清单 7.EHCache 示例代码
    import net.sf.ehcache.Cache;
    import net.sf.ehcache.CacheManager;
    import net.sf.ehcache.Element;
    /**
     * 第一步:生成 CacheManager 对象
     * 第二步:生成 Cache 对象
     * 第三步:向 Cache 对象里添加由 key,value 组成的键值对的 Element 元素
     * @author mahaibo
     *
     */
    public class EHCacheDemo{
    
    public static void main(String[] args) {
     //指定 ehcache.xml 的位置
     String fileName="E:\\1008\\workspace\\ehcachetest\\ehcache.xml";
     CacheManager manager = new CacheManager(fileName);
     //取出所有的 cacheName
     String names[] = manager.getCacheNames();
     for(int i=0;i<names.length;i++){
     System.out.println(names[i]);
     }
     //根据 cacheName 生成一个 Cache 对象
     //第一种方式:
     Cache cache=manager.getCache(names[0]);
     
     //第二种方式,ehcache 里必须有 defaultCache 存在,"test"可以换成任何值
    // Cache cache = new Cache("test", 1, true, false, 5, 2); 
    // manager.addCache(cache); 
     
     //向 Cache 对象里添加 Element 元素,Element 元素有 key,value 键值对组成
     cache.put(new Element("key1","values1"));
     Element element = cache.get("key1");
     
     System.out.println(element.getValue());
     Object obj = element.getObjectValue();
     System.out.println((String)obj);
     manager.shutdown();
     
    
     }
    
    
    }

    对象复用

    对象复用池是目前很常用的一种系统优化技术。它的核心思想是,如果一个类被频繁请求使用,那么不必每次都生成一个实例,可以将这个类的一些实例保存在一个“池”中,待需要使用的时候直接从池中获取。这个“池”就称为对象池。在实现细节上,它可能是一个数组,一个链表或者任何集合类。对象池的使用非常广泛,例如线程池和数据库连接池。线程池中保存着可以被重用的线程对象,当有任务被提交到线程时,系统并不需要新建线程,而是从池中获得一个可用的线程,执行这个任务。在任务结束后,不需要关闭线程,而将它返回到池中,以便下次继续使用。由于线程的创建和销毁是较为费时的工作,因此,在线程频繁调度的系统中,线程池可以很好地改善性能。数据库连接池也是一种特殊的对象池,它用于维护数据库连接的集合。当系统需要访问数据库时,不需要重新建立数据库连接,而可以直接从池中获取;在数据库操作完成后,也不关闭数据库连接,而是将连接返回到连接池中。由于数据库连接的创建和销毁是重量级的操作,因此,避免频繁进行这两个操作对改善系统的性能也有积极意义。目前应用较为广泛的数据库连接池组件有 C3P0 和 Proxool。

    以 C3P0 为例,它是一个开源的 JDBC 连接池,它实现了数据源和 JNDI 绑定,支持 JDBC3 规范和 JDBC2 的标准扩展。目前使用它的开源项目有 Hibernate,Spring 等。如果采用 JNDI 方式配置,如清单 8 所示。

    清单 8.Tomcat 数据源配置
    <Resource name="jdbc/dbsource" 
     type="com.mchange.v2.c3p0.ComboPooledDataSource" 
     maxPoolSize="50" minPoolSize="5" acquireIncrement="2" initialPoolSize="10" maxIdleTime="60"
     factory="org.apache.naming.factory.BeanFactory" 
     user="xxxx" password="xxxx" 
     driverClass="oracle.jdbc.driver.OracleDriver" 
     jdbcUrl="jdbc:oracle:thin:@192.168.x.x:1521:orcl" 
     idleConnectionTestPeriod="10" />

    参数说明:

    1. idleConnectionTestPerio:当数据库重启后或者由于某种原因进程被杀掉后,C3P0 不会自动重新初始化数据库连接池,当新的请求需要访问数据库的时候,此时会报错误 (因为连接失效),同时刷新数据库连接池,丢弃掉已经失效的连接,当第二个请求到来时恢复正常。C3P0 目前没有提供当获取已建立连接失败后重试次数的参数,只有获取新连接失败后重试次数的参数。
    2. acquireRetryAttempts:该参数的作用是设置系统自动检查连接池中连接是否正常的一个频率参数,时间单位是秒。
    3. acquireIncremen:当连接池中的的连接耗尽的时候 c3p0 一次同时获取的连接数,也就是说,如果使用的连接数已经达到了 maxPoolSize,c3p0 会立即建立新的连接。
    4. maxIdleTim:另外,C3P0 默认不会 close 掉不用的连接池,而是将其回收到可用连接池中,这样会导致连接数越来越大,所以需要设置 maxIdleTime(默认 0,表示永远不过期),单位是秒,maxIdleTime 表示 idle 状态的 connection 能存活的最大时间。

    如果使用 spring,同时项目中不使用 JNDI,又不想配置 Hibernate,可以直接将 C3P0 配置到 dataSource 中即可,如清单 9 所示。

    清单 9.Spring 配置
    <bean id="dataSource" destroy-method="close">
    <property name="driverClass"><value>oracle.jdbc.driver.OracleDriver</value></property>
    <property name="jdbcUrl"><value>jdbc:oracle:thin:@localhost:1521:Test</value></property>
    <property name="user"><value>Kay</value></property>
    <property name="password"><value>root</value></property>
    <!--连接池中保留的最小连接数。-->
    <property name="minPoolSize" value="10" />
    <!--连接池中保留的最大连接数。Default: 15 -->
    <property name="maxPoolSize" value="100" />
    <!--最大空闲时间,1800 秒内未使用则连接被丢弃。若为 0 则永不丢弃。Default: 0 -->
    <property name="maxIdleTime" value="1800" />
    <!--当连接池中的连接耗尽的时候 c3p0 一次同时获取的连接数。Default: 3 -->
    <property name="acquireIncrement" value="3" />
    <property name="maxStatements" value="1000" />
    <property name="initialPoolSize" value="10" />
    <!--每 60 秒检查所有连接池中的空闲连接。Default: 0 -->
    <property name="idleConnectionTestPeriod" value="60" />
    <!--定义在从数据库获取新连接失败后重复尝试的次数。Default: 30 -->
    <property name="acquireRetryAttempts" value="30" />
    <property name="breakAfterAcquireFailure" value="true" />
    <property name="testConnectionOnCheckout" value="false" />
    </bean>

    类似的做法存在很多种,用户可以自行上网搜索。

    计算方式转换

    计算方式转换比较出名的是时间换空间方式,它通常用于嵌入式设备,或者内存、硬盘空间不足的情况。通过使用牺牲 CPU 的方式,获得原本需要更多内存或者硬盘空间才能完成的工作。

    一个非常简单的时间换空间的算法,实现了 a、b 两个变量的值交换。交换两个变量最常用的方法是使用一个中间变量,而引入额外的变量意味着要使用更多的空间。采用下面的方法可以免去中间变量,而达到变量交换的目的,其代价是引入了更多的 CPU 运算。

    清单 10. 示例代码
    a=a+b;
    b=a-b;
    a=a-b;

    另一个较为有用的例子是对无符号整数的支持。在 Java 语言中,不支持无符号整数,这意味着当需要无符号的 Byte 时,需要使用 Short 代替,这也意味着空间的浪费。下面代码演示了使用位运算模拟无符号 Byte。虽然在取值和设值过程中需要更多的 CPU 运算,但是可以大大降低对内存空间的需求。

    清单 11. 无符号整数运算
    public class UnsignedByte {
     public short getValue(byte i){//将 byte 转为无符号的数字
     short li = (short)(i & 0xff);
     return li;
     }
     
     public byte toUnsignedByte(short i){
     return (byte)(i & 0xff);//将 short 转为无符号 byte
     }
     
     public static void main(String[] args){
     UnsignedByte ins = new UnsignedByte();
     short[] shorts = new short[256];//声明一个 short 数组
     for(int i=0;i<shorts.length;i++){//数组不能超过无符号 byte 的上限
     shorts[i]=(short)i;
     }
     byte[] bytes = new byte[256];//使用 byte 数组替代 short 数组
     for(int i=0;i<bytes.length;i++){
     bytes[i]=ins.toUnsignedByte(shorts[i]);//short 数组的数据存到 byte 数组中
     }
     for(int i=0;i<bytes.length;i++){
     System.out.println(ins.getValue(bytes[i])+" ");//从 byte 数组中取出无符号的 byte
     }
     }
    }

    运行输出如清单 12 所示,篇幅所限,只显示到 10 为止。

    清单 12. 运行输出
    0 
    1 
    2 
    3 
    4 
    5 
    6 
    7 
    8 
    9 
    10

    如果 CPU 的能力较弱,可以采用牺牲空间的方式提高计算能力,实例代码如清单 13 所示。

    清单 13. 提高计算能力
    import java.util.Arrays;
    import java.util.HashMap;
    import java.util.Map;
    
    
    public class SpaceSort {
     public static int arrayLen = 1000000;
     
     public static void main(String[] args){
     int[] a = new int[arrayLen];
     int[] old = new int[arrayLen];
     Map<Integer,Object> map = new HashMap<Integer,Object>();
     int count = 0;
     while(count < a.length){
     //初始化数组
     int value = (int)(Math.random()*arrayLen*10)+1;
     if(map.get(value)==null){
     map.put(value, value);
     a[count] = value;
     count++;
     }
     }
     System.arraycopy(a, 0, old, 0, a.length);//从 a 数组拷贝所有数据到 old 数组
     long start = System.currentTimeMillis();
     Arrays.sort(a);
     System.out.println("Arrays.sort spend:"+(System.currentTimeMillis() - start)+"ms");
     System.arraycopy(old, 0, a, 0, old.length);//恢复 原有数据
     start = System.currentTimeMillis();
     spaceTotime(a);
     System.out.println("spaceTotime spend:"+(System.currentTimeMillis() - start)+"ms");
     }
     
     public static void spaceTotime(int[] array){
     int i = 0;
     int max = array[0];
     int l = array.length;
     for(i=1;i<l;i++){
     if(array[i]>max){
     max = array[i];
     }
     }
     int[] temp = new int[max+1];
     for(i=0;i<l;i++){
     temp[array[i]] = array[i];
     }
     int j = 0;
     int max1 = max + 1;
     for(i=0;i<max1;i++){
     if(temp[i] > 0){
     array[j++] = temp[i];
     }
     }
     }
    }

    函数 spaceToTime() 实现了数组的排序,它不计空间成本,以数组的索引下标来表示数据大小,因此避免了数字间的相互比较,这是一种典型的以空间换时间的思路。

    结束语

    应对、处理高吞吐量系统有很多方面可以入手,作者将以系列的方式逐步介绍覆盖所有领域。本文主要介绍了缓冲区、缓存操作、对象复用池、计算方式转换等优化及建议,从实际代码演示入手,对优化建议及方案进行了验证。作者始终坚信,没有什么优化方案是百分百有效的,需要读者根据实际情况进行选择、实践。

    展开全文
  • 最近我做了一些以太网吞吐量和丢包方面的优化工作,有一些心得和大家分享一下。 一、测试模型 二、影响吞吐量和丢包的因素 1. 网卡DMA缓冲区大小 这个缓冲区决定tx ring buffer和rx ring buffer的大小...

    现在有很多硬件平台理论上支持千兆以太网接口,但实际传输速率远远低于千兆,并且丢包率很高。最近我做了一些以太网吞吐量和丢包率方面的优化工作,有一些心得和大家分享一下。

    一、测试模型

     

    二、影响吞吐量和丢包率的因素

    1. 网卡DMA缓冲区大小

        这个缓冲区决定tx ring buffer和rx ring buffer的大小,如果ring buffer太小,那么网卡缓存数据包的能力有限,当接收数据能力超过cpu处理能力时就会产生丢包现象。ring buffer越大,吞吐能力就越强,丢包的概率就越小。

     

    2. CPU处理能力

        CPU处理速度越快,网卡接收到的数据包在网卡DMA缓冲区中的存留时间就越短,因此就可以腾出更多的空间来暂存新接收到的数据包。因此,CPU的处理能力直接决定了系统的吞吐量,运算速度越快,吞吐量越高。

     

    3. 内存总容量

        当网卡DMA缓冲区太小时,ring buffer不够用,会造成网络数据丢包。此时,需要将数据包及时从ring buffer里面取出来,暂存到接收队列里面(发送数据时同理)。然后在合适的时机再把数据包上传给协议栈。这种处理方式会瞬时大量消耗系统内存,当吞吐量很大时,会引起内存剩余容量抖动,甚至导致内存不足的异常出现。

     

    三、调试注意事项

    1. 当前ring buffer是否设置为网卡最大ring buffer;

    2. 高负载时注意CPU占用率,重点关注软中断和网络数据包处理线程的占用率总和;

    3. 关注low memory剩余容量,长时间测试时,剩余容量是否有下降趋势;

    4. 长时间测试后,查看log,系统是否有出现异常报警;

     

    四、推荐优化方法

    1. 提高CPU处理能力,例如提升CPU频率或者运行模式;

    2. 提高内存总容量,增加系统内存或者更换更大的内存;

    3. 优化软中断收发包的处理方法,将软中断处理数据包的过程分为两步处理。例如把收包放到软中断里面处理,把数据包上报协议栈放到内核线程处理,类似于上半部和下半部。这样做可以减少中断屏蔽时间,尽可能多的接收外部数据到网卡缓冲区,从而增加吞吐量。同时,用内核线程去上报数据包到协议栈可以避免丢包。

     

    上面介绍了千兆网卡提升吞吐量和减小丢包率的方法,我实际测试有很大的改善,分享出来供大家参考。

    当然,实际优化过程中可能会遇到更种问题,本文仅仅提供优化思路。

     

     

     

     

     

    展开全文
  • 流水线和吞吐率

    千次阅读 2017-07-02 14:12:30
    当全速执行的时候,每个时钟周期结束都有一条指令处理完,而新时钟周期Tclk2明显比之前没流水线时候Tclk1小了,所以我们说吞吐率提高了。如果你只关注一条指令的实际执行时间(注意每条指令花三个时钟周期完成): 3...
     流水线设计将原来一个时钟周期完成的较大的组合逻辑,通过切割后分由多个时钟完成,所以,该部分逻辑运行的时钟频率会有明显提升,流水线设计只在开始处理时需要一定的处理时间,以后就会不间断的输出数据,从而大大提高处理速度,所以系统的频率就提高了。
    jumphigh1987 (2012-8-06 15:02:06)

    9楼正解! 假如以前一个组合逻辑需要50纳秒完成,那其对外显示的就是50ns才能完成这个功能,之后每50纳秒完成这个功能。 引入流水线以后(假如分成十级,每级5纳秒),第一次这个功能需要50纳秒出来结果,之后每隔5纳秒就会输出一个结果。 以前对外显示的是50纳秒完成,此时就显示成了5纳秒完成,效率提高了10倍。 流水线就是在串行中完成了形式上的并行。



    您好,这样的; 流水线的引入提高的只是得系统的Throughput (吞吐率),即全速工作时候,单位时间内执行的指令数目增加了。但是如果仅看单条指令的绝对执行时间,这个量必然是增加的:因为 每多插入一级D flip-flop必然引入sequencing overhead(中文翻译时序支出?我不知道我翻译的对不对)。 具体来说,举例子: a没流水线的时候,时钟周期最小Tclk1>=Tsetup+Tpd_critical ,每条指令一个时钟周期执行完。其中Tsetup为触发器的建立时间,Tpd_critical为关键路径的最坏传输延迟。 b假设我采用级流水线,每一级组合逻辑的critcal delay均分 (是之前critical delay的1/3, 即Tpd_critical/3) ,新时钟周期 Tclk2>=Tsetup+Tpd_critical/3 ,每条指令要花三个时钟周期执行完。当全速执行的时候,每个时钟周期结束都有一条指令处理完,而新时钟周期Tclk2明显比之前没流水线时候Tclk1小了,所以我们说吞吐率提高了。如果你只关注一条指令的实际执行时间(注意每条指令花三个时钟周期完成): 3* Tsetup+Tpd_critical/3)= 3*Tsetup + Tpd_critical 你发现绝对时间来看,单条指令执行时间反而比没流水线时候大了。多出来2个Tsetup就是所谓的sequencing overhead。 注意实际情况可能比上述复杂,但是上述例子用来解释本问题是足够的了。 接下来还要注意一点:我们说吞吐率提高了,只是在“全速工作”的情况下。前面还有人作答提到P4的高频低能问题。其实这个问题又得从流水线的本质来解释。比如,如果由于某种原因processor就是没法全速工作怎么办?这种情况还不少见:比如我们有指令1指令2指令3,其中 指令2的执行依赖于指令1的结果,然后指令3的执行又依赖于指令2的结果。当出现这种情况时候,必须等前面一条指令完全执行完毕,产生结果之后,下条指令才能开始执行。当这种情况出现过多的时候,流水线的存在不仅没有多大帮助,反而因为多出来的sequencing overhead让性能降低。 总之,很多关于计算机硬件的问题如果想要究其本质,需要离开你平时所工作的level of abstraction(抽象层级)到更加底层的层次中去。




    在谈这张图之前,我们再看一个概念:K阶流水线。

    K阶段流水线(“K流水线”)是一个非循环电路,对应于从输入到输出的每一条路径恰好有K个寄存器。因此前面的电路为啥是2阶应该清楚了。通时,我们还可以知道,1、组合逻辑电路是0阶流水线;2、在K阶段流水线中,每个流水线阶段的输出(而不是输入)都有一个寄存器。好,我们接着谈上面的流水线时空图。

    通过流水线时空图,我们观察到,当流水线每个阶段都开始工作后,每一个时钟周期都会有一个结果的输出,也就是说K阶段流水线的吞吐量即是时钟频率,而K阶流水线的延时是对所有寄存器公用的时钟周期的K倍
    同时我们也可以观察到,所有的流水级都只花费一个时钟周期的时间,因此,时钟周期必须能够满足最慢操作的执行需要
    因此我们可以得出
    指令执行时间(流水线)=指令执行时间(非流水线)/流水线级数
    即在理想情况和有大量指令的情况下,流水线所带来的加速比与流水线的级数近似相同。例如一个5级流水线能够获得的加速比接近于5。

    而这样一种技术如果用到电脑里面岂不能提高性能啦?没错,我们现在的电脑里面跑的CPU就用到了流水线技术,通过这样的一种技术,提高了指令的吞吐率,从而带来了性能的提高。注意:流水线所带来的性能提高是通过增加指令的吞吐率,而不是减少单条指令的执行时间实现的。为什么呢?这就好像洗衣服,干衣服用的时间没变,但是最终的产出却是增加了的道理一样。


    展开全文
  • 一、吞吐率 我们一般使用单位时间内服务器处理的请求数来描述其并发处理能力。称之为吞吐率(Throughput),单位是 “req/s”。吞吐率特指Web服务器单位时间内处理的请求数。 比如Apache 的 mod_status 模块提供的...
  • 优化吞吐

    2016-11-20 12:05:01
    在这一步里面,你需要测试应用的吞吐量和为了更高的吞吐量而优化JVM。  这一步的输入就是应用的吞吐量性能要求。应用的吞吐量是在应用层面衡量而不是在JVM层面衡量,因此,应用必须要报告出一些吞吐量指标或者...
  • WIFI吞吐率的提升方法

    千次阅读 2017-08-14 17:36:35
    WIFI Throughput 测试 debug 方法 1) 检查客户的 WLAN NV 是否和原理图设计匹配, 2) 请确认是 2.4GHz 的 Throughput 比较差还是 5GHz 的 Throughput 比较差 3) 请确认 ini 文件中的 40MHz BW 是否已经打开, ...
  • 上行PHR余量提升优化思路

    万次阅读 多人点赞 2019-06-21 10:20:58
    表示判断UE异常时上行连续CRC错误次数的门限值,当AbnUeSchSwitch(异常UE停止调度算法开关)开关为开时,启用解决异常UE调度问题方案,可以减小RBLER,在资源受限的场景下可以提升小区吞吐率。 3、近点用户参数...
  • 专注于分享4/5G网优资料:包括网络优化基础原理资料、各厂家常用网管指导、接入、切换、掉线、高丢包、干扰分析、速率、容量负载均衡、覆盖单验簇优化、各类网优常用工具合集
  • 4G优化
  • 一、吞吐率 我们一般使用单位时间内服务器处理的请求数来描述其并发处理能力。称之为吞吐率(Throughput),单位是 “req/s”。吞吐率特指Web服务器单位时间内处理的请求数。 比如Apache 的 mod_status 模块...
  • P2P系统的本质任务在于提高资源利用和系统吞吐量,满足更多用户的数据请求。...模拟实验数据表明,基于带宽和搜索成功的覆盖网络优化方案可以以很小代价提高系统吞吐量,当文件体积较小时提高比例可高达22%。
  • 但是存在预测结果不准确的情况,影响整个网络的吞吐率。在基于遗传算法优化的神经网络预测模型基础上,提出了SU进行协作的频谱预测方法,提高了SU预测空闲信道的准确率。讨论了协作频谱预测条件下,在通信强度、协作...
  • (二)吞吐量、吞吐率、事务、TPS、QPS 吞吐量: 每秒的数据处理量 在给定的时间内系统完成的交易数量,即系统的吞吐量越大,说明系统在单位时间内完成的用户系统请求越多,资源越得到充分的利用 反应的是服务器...
  • 专注于分享4/5G网优资料:包括网络优化基础原理资料、各厂家常用网管指导、接入、切换、掉线、高丢包、干扰分析、速率、容量负载均衡、覆盖单验簇优化、各类网优常用工具合集
  • 指令系统计算机的基本概念指令系列机AmdahlAmdahlAmdahl定律CPU性能公式系统结构的评价标准等效指令速度指令系统主流指令系统指令系统的设计与优化指令组成指令系统的优化指令字格式的优化缩短地址码地址码优化指令...
  • 专注于分享4/5G网优资料:包括网络优化基础原理资料、各厂家常用网管指导、接入、切换、掉线、高丢包、干扰分析、速率、容量负载均衡、覆盖单验簇优化、各类网优常用工具合集
  • 基于路测,对单站的网络优化重要指标进行分析,并结合实测数据对可能造成无线网络上下行吞吐率不稳定等问题的原因进行排查定位,达到覆盖、容量、质量的最佳组合,提高用户满意度,提升运营商的品牌形象。
  • 性能优化指标-吞吐量,响应时间 性能优化指标 一、名词解释 RT = return time 响应时间 PV=page view 页面浏览数 TPS=transactions per second 每...
  • JVM之优化吞吐

    2017-02-09 18:02:59
    JVM之优化吞吐量   对年轻代进行优化   优化吞吐量的目的其实是尽量少的Full GC ,或者尽量避免Full GC,有以下方法可以尽量减少Full GC:   增大Eden:你可以让eden空间更大,可以减少MinorGC的次数。我...
  • Logstash吞吐量性能优化

    万次阅读 2017-12-27 16:16:22
    ELK工具之logstash在导入数据的时候,如果面临的是数据量非常大的集群环境,则需要进行具体的优化配置;
  • 井楼油田七区核Ⅳ2-3小层属普通稠油油藏,经过多年...结合河南油田技术应用现状,通过建立三维地质模型,利用数据模拟进行化学辅助蒸汽吞吐注入浓度优化设计研究,为经济有效提高浅薄层普通稠油油藏采收提供依据。
  • 可见,通常所讲的最大并发数是有一定利益前提的,那就是服务器和用户双方所期待的最大收益,服务器希望支持高并发数及高吞吐率,而用户不管那么多,只希望等待较少的时间,或者得到更快的下载速度。 所以得出最大...
  • 针对一些对实时性要求较高而数据吞吐量不高的网络服务,提出一种有效减小时延...通过对协议的时延、吞吐量和总线利用进行仿真,与一般的p-坚持CSMA/CD协议相比,自适应p-坚持CSMA/CD协议能较有效降低时延、减小抖动。
  • LR结果分析— TPS和吞吐率

    千次阅读 2011-11-26 15:53:13
    【IT168 技术文档】针对吞吐率和TPS的关系,这个在结果分析中如何使用,就个人经验和朋友讨论后,提出如下建议指导,欢迎同僚指正。  TPS:transaction per second 服务器每秒处理的事务数。  吞吐率:测试过程...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 67,063
精华内容 26,825
关键字:

吞吐率优化