服务器100M带宽什么概念？100M上行速度和下行速度是多少？

100M的带宽究竟有多快？

根据我们日常使用规则呢，我们宽带的100兆指的是带宽MB=Mbit，大部分用户以为宽带安装的是多少兆下载就是多少了。

以前一个朋友，装了4M的宽带下载速度只有几百K，他就吐槽嘛,骂运营商给的不够。

其实不是这样的，这样理解是错误的。

就是说1MByte=8Mbit所以说我们一百兆的宽带每秒下载的速度就等于说100MB除以8等于125MB，4MB除以8=05MB，这就说是理论上的峰值速度。

现实中，因为路由器和其他方面的信号干扰，一般是达不到这个峰值的。

例:

1MByte=8Mbit

100MB/8=125MB

4MB/8=05MB/s

上行速度与下行速度有什么区别？

在我们这边运行商主要是联通和电信了。

他的上行和下行有很大区别的，一般来说下行宽带是100兆的话上行只有8兆， 也就是说你如果是100兆的宽带上传的速度只能达到1M一秒，下载速度一般是9MB左右，普通家庭根本用不着上行宽带，最耗费上行宽带的QQ或者微信视频聊天，亲测只需要128KB/s的稳定上传就可以流畅不卡了。

然后我们多余的上行宽带可以卖给有需求的企业用户了，比如上下行对等的的10兆光纤（专线）他们用的是静态IP不是动态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_;

}

带宽和速度是两个概念如果把速度比做流水速度的话那么带宽就相当于水管的粗细也就是说带宽越大能承载的同一时间访问量也就越多通常服务器的带宽是不分上下行的3M带宽就是指总共带宽3M用户访问时所占用的当然也是这台服务器的带宽

海腾数据杨闯为你解答希望对你有帮助

看你开几个区的，一个区的话最低配置1核1G1M就可以开了，支持个30人左右不是问题，你要开十几个区，要架设微端，自然服务器配置宽带要求都会高起来，而且做商业的话机器都要带防御的，我建议你先自己学学，要不然说了你都不懂，送你一份传奇架设教程，希望对你有帮助 网页链接