测试服务器带宽的几种常用的方法有哪些？

一、下载测试法

下载测试法主要是将一个大型的文件放置在服务器上，然后通过下载的方法来对带宽的下载速度和稳定性进行测试，这种方法比较适用，特别是对于搭建下载网站或者在线视频这种需要大带宽支持的用户来说。不过通常这种方法也需要服务商的配合。一般情况下：

1Mbps的带宽下载速度：100K-150K/S

2Mbps是200-280K/S

4Mbps是400K-500K/S

8Mbps是800-950K/S

10Mbps光纤共享能达到1M-15M/S

注：(1Mbps宽带理论下载速度128K/s，2Mbps宽带理论256K/s，4Mbps是512K/s)

2、使用Ping测试网速

通过ping

服务商所提供的IP地址来对网络的当前情况进行测试。但是需要注意的是这种方法只是对带宽的一个估算，而不是直观地将数值表现出来，这种方法最重要的测试服务器的访问速度稳定性。

3、使用测试网站

只要用户在搜索引擎上一搜，其实有很多网速测试网站可以进行网速测试，是最常用的网速测试方法，而且用户根据网络使用情况选择测试线路，测试点遍及全国各省、美国、澳大利亚、日本等海外国家，用户可选择任意测试点进行测试，网站采用flash实现测速功能，可视化的测试过程，测试结果能准确反映本地网络速率，无需下载安装插件或添加额外设备，使用简单，操作方便。

4、使用路由跟踪

常见的路由跟踪命令行 windows有Tracert和winmtr， Linux下有traceroute和mtr，

windows的winmtr是带gui的使用比较简单。根据以上带宽的速度，然后除页面文件大小，乘以打开页面的时间（秒为单位）。这样就可以算出1M带宽能同时承受多少人访问了。

网站服务器的带宽是指你的服务器接入到运营商的接口带宽，就好比是一条进入你网站的路，带宽越大，能走的车就越多，网站的能访问的人就越多，如果带宽小了的话，别人打开这个网站会很慢，比较卡。

访问量就是某段时间内有多少人进入了这个网站。

一天有三万IP，说明每小时也就一千多人进入这个网站，每分种十到二十个人打开这个网页，这对带宽的需要求量不是很大。

webrtc中的带宽自适应算法分为两种：

1，　发端带宽控制，　原理是由rtcp中的丢包统计来动态的增加或减少带宽，在减少带宽时使用TFRC算法来增加平滑度。

2，　收端带宽估算，　原理是并由收到rtp数据，估出带宽；　用卡尔曼滤波，对每一帧的发送时间和接收时间进行分析，　从而得出网络带宽利用情况，修正估出的带宽。

两种算法相辅相成，　收端将估算的带宽发送给发端，　发端结合收到的带宽以及丢包率，调整发送的带宽。

下面具体分析两种算法：

2, 接收端带宽估算算法分析

结合文档http://toolsietforg/html/draft-alvestrand-rtcweb-congestion-02以及源码webrtc/modules/remote_bitrate_estimator/overuse_detectorcc进行分析

带宽估算模型： d(i) = dL(i) / c + w(i) d(i)两帧数据的网络传输时间差，dL(i)两帧数据的大小差， c为网络传输能力， w(i)是我们关注的重点， 它主要由三个因素决定：发送速率， 网络路由能力， 以及网络传输能力。w(i)符合高斯分布， 有如下结论：当w(i)增加是，占用过多带宽（over-using)；当w(i)减少时，占用较少带宽（under-using)；为0时，用到恰好的带宽。所以，只要我们能计算出w(i)，即能判断目前的网络使用情况，从而增加或减少发送的速率。

算法原理：即应用kalman-filters

theta_hat(i) = [1/C_hat(i) m_hat(i)]^T // i时间点的状态由C, m共同表示，theta_hat(i)即此时的估算值

z(i) = d(i) - h_bar(i)^T theta_hat(i-1) //d(i)为测试值，可以很容易计算出， 后面的可以认为是d(i-1)的估算值， 因此z(i)就是d(i)的偏差，即residual

theta_hat(i) = theta_hat(i-1) + z(i) k_bar(i) //好了，这个就是我们要的结果，关键是k值的选取，下面两个公式即是取k值的，具体推导见后继博文。

E(i-1) h_bar(i)

k_bar(i) = --------------------------------------------

var_v_hat + h_bar(i)^T E(i-1) h_bar(i)

E(i) = (I - K_bar(i) h_bar(i)^T) E(i-1) + Q(i) // h_bar(i)由帧的数据包大小算出

由此可见，我们只需要知道当前帧的长度，发送时间，接收时间以及前一帧的状态，就可以计算出网络使用情况。

接下来具体看一下代码：

[cpp] view

plaincopy

void OveruseDetector::UpdateKalman(int64_t t_delta,

double ts_delta,

uint32_t frame_size,

uint32_t prev_frame_size) {

const double min_frame_period = UpdateMinFramePeriod(ts_delta);

const double drift = CurrentDrift();

// Compensate for drift

const double t_ts_delta = t_delta - ts_delta / drift; //即d(i)

double fs_delta = static_cast<double>(frame_size) - prev_frame_size;

// Update the Kalman filter

const double scale_factor = min_frame_period / (10000 / 300);

E_[0][0] += process_noise_[0] scale_factor;

E_[1][1] += process_noise_[1] scale_factor;

if ((hypothesis_ == kBwOverusing && offset_ < prev_offset_) ||

(hypothesis_ == kBwUnderusing && offset_ > prev_offset_)) {

E_[1][1] += 10 process_noise_[1] scale_factor;

}

const double h[2] = {fs_delta, 10}; //即h_bar

const double Eh[2] = {E_[0][0]h[0] + E_[0][1]h[1],

E_[1][0]h[0] + E_[1][1]h[1]};

const double residual = t_ts_delta - slope_h[0] - offset_; //即z(i)， slope为1／C

const bool stable_state =

(BWE_MIN(num_of_deltas_, 60) fabsf(offset_) < threshold_);

// We try to filter out very late frames For instance periodic key

// frames doesn't fit the Gaussian model well

if (fabsf(residual) < 3 sqrt(var_noise_)) {

UpdateNoiseEstimate(residual, min_frame_period, stable_state);

} else {

UpdateNoiseEstimate(3 sqrt(var_noise_), min_frame_period, stable_state);

}

const double denom = var_noise_ + h[0]Eh[0] + h[1]Eh[1];

const double K[2] = {Eh[0] / denom,

Eh[1] / denom}; //即k_bar

const double IKh[2][2] = {{10 - K[0]h[0], -K[0]h[1]},

{-K[1]h[0], 10 - K[1]h[1]}};

const double e00 = E_[0][0];

const double e01 = E_[0][1];

// Update state

E_[0][0] = e00 IKh[0][0] + E_[1][0] IKh[0][1];

E_[0][1] = e01 IKh[0][0] + E_[1][1] IKh[0][1];

E_[1][0] = e00 IKh[1][0] + E_[1][0] IKh[1][1];

E_[1][1] = e01 IKh[1][0] + E_[1][1] IKh[1][1];

// Covariance matrix, must be positive semi-definite

assert(E_[0][0] + E_[1][1] >= 0 &&

E_[0][0] E_[1][1] - E_[0][1] E_[1][0] >= 0 &&

E_[0][0] >= 0);

slope_ = slope_ + K[0] residual; //1/C

prev_offset_ = offset_;

offset_ = offset_ + K[1] residual; //theta_hat(i)

Detect(ts_delta);

}

[cpp] view

plaincopy

BandwidthUsage OveruseDetector::Detect(double ts_delta) {

if (num_of_deltas_ < 2) {

return kBwNormal;

}

const double T = BWE_MIN(num_of_deltas_, 60) offset_; //即gamma_1

if (fabsf(T) > threshold_) {

if (offset_ > 0) {

if (time_over_using_ == -1) {

// Initialize the timer Assume that we've been

// over-using half of the time since the previous

// sample

time_over_using_ = ts_delta / 2;

} else {

// Increment timer

time_over_using_ += ts_delta;

}

over_use_counter_++;

if (time_over_using_ > kOverUsingTimeThreshold //kOverUsingTimeThreshold是gamma_2， gamama_3=1

&& over_use_counter_ > 1) {

if (offset_ >= prev_offset_) {

time_over_using_ = 0;

over_use_counter_ = 0;

hypothesis_ = kBwOverusing;

}

}

} else {

time_over_using_ = -1;

over_use_counter_ = 0;

hypothesis_ = kBwUnderusing;

}

} else {

time_over_using_ = -1;

over_use_counter_ = 0;

hypothesis_ = kBwNormal;

}

return hypothesis_;

}