网络带宽预测方法

typedef struct SDL_SpeedSampler2

{

    int64_t sample_range;//采样点的时间范围，初始化时定义，后续不会修改，默认值是2000ms

    int64_t last_profile_tick;//上一次采样的时间

    int64_t last_profile_duration;//之前所有采样下载时间的加权均值

    int64_t last_profile_quantity;//之前所有采样下载数据量的加权均值

    int64_t last_profile_speed;//上一次采样时的平均带宽

} SDL_SpeedSampler2;

//函数参数只有两个，分别是采样结构体的指针和本次采样下载的数据量

int64_t SDL_SpeedSampler2Add(SDL_SpeedSampler2 *sampler, int quantity)

{

    if (quantity < 0)

        return 0;

    int64_t sample_range  = sampler->sample_range;

    int64_t last_tick     = sampler->last_profile_tick;

    int64_t last_duration = sampler->last_profile_duration;

    int64_t last_quantity = sampler->last_profile_quantity;

    int64_t now           = (int64_t)SDL_GetTickHR();

    //这里使用两次采样的间隔作为本次采样的下载时间

    int64_t elapsed       = (int64_t)llabs(now - last_tick);

    //如果两次采样的间隔时间超过了sample_range，那么之前的采样信息便不再置信，因此需要重新统计采样信息，将本次采样作为第一次采样

    if (elapsed < 0 || elapsed >= sample_range) {

        // overflow, reset to initialized state

        sampler->last_profile_tick     = now;

        sampler->last_profile_duration = sample_range;

        sampler->last_profile_quantity = quantity;

        sampler->last_profile_speed    = quantity * 1000 / sample_range;

        return sampler->last_profile_speed;

    }

    //这里就是加权算法的部分，这里的last_quantity和last_duration都是从0开始增长的，即new_quantity和new_duration也是从0开始增长的。当new_duration小于sample_range时，

    //即第一个采样点与最后一个采样点的时间差在sample_range范围内时，new_duration和new_quantity的权重都还是1，即未经过加权；一旦new_duration大于sample_range后，new_duration

    //的值就会被固定为sample_range，new_quantity则按比例进行缩小，这也就变相地实现了，越靠前的采样点，随着时间的推移，所占的比重会越来越小。

    int64_t new_quantity = last_quantity + quantity;

    int64_t new_duration = last_duration + elapsed;

    if (new_duration > sample_range) {

        new_quantity = new_quantity * sample_range / new_duration;

        new_duration = sample_range;

    }

    //这部分逻辑比较简单了，更新变量然后算出当前平均带宽。

    sampler->last_profile_tick     = now;

    sampler->last_profile_duration = new_duration;

    sampler->last_profile_quantity = new_quantity;

    if (new_duration > 0)

        sampler->last_profile_speed = new_quantity * 1000 / new_duration;

    return sampler->last_profile_speed;

}

int64_t SDL_SpeedSampler2GetSpeed(SDL_SpeedSampler2 *sampler)

{

    int64_t sample_range  = sampler->sample_range;

    int64_t last_tick     = sampler->last_profile_tick;

    int64_t last_quantity = sampler->last_profile_quantity;

    int64_t last_duration = sampler->last_profile_duration;

    int64_t now           = (int64_t)SDL_GetTickHR();

    int64_t elapsed       = (int64_t)llabs(now - last_tick);

    if (elapsed < 0 || elapsed >= sample_range)

        return 0;

    //这里存在一个问题，就是elapsed是已知的，因此可以直接加到duration里，但是这段时间下载的数据量quantity是未知的，因此new_quantity是比实际值要小的，最终导致预测的带宽也要比

    //实际值小一点，且elapsed越大，这个误差会越明显

    int64_t new_quantity = last_quantity;

    int64_t new_duration = last_duration + elapsed;

    if (new_duration > sample_range) {

        new_quantity = new_quantity * sample_range / new_duration;

        new_duration = sample_range;

    }

    if (new_duration <= 0)

        return 0;

    return new_quantity * 1000 / new_duration;

}

//重载了两种COMPARATOR，分别比较采样点的index和value

private static final Comparator<Sample> INDEX_COMPARATOR = (a, b) -> a.index - b.index;

private static final Comparator<Sample> VALUE_COMPARATOR =

    (a, b) -> Float.compare(a.value, b.value);

//排序方式，按照index排序或按照value排序

private static final int SORT_ORDER_NONE = -1;

private static final int SORT_ORDER_BY_VALUE = 0;

private static final int SORT_ORDER_BY_INDEX = 1;

//回收区的最大数量

private static final int MAX_RECYCLED_SAMPLES = 5;

//最大权重，即滑动窗口的大小

private final int maxWeight;

//采样点列表

private final ArrayList<Sample> samples;

//回收区采样点列表，这里为了避免采样点的频繁创建与销毁，新增了回收区

private final Sample[] recycledSamples;

//当前排序方式

private int currentSortOrder;

//下一个采样点的index

private int nextSampleIndex;

//当前权重和

private int totalWeight;

//已回收的采样点数量

private int recycledSampleCount;

private static class Sample {

  public int index;

  //当前采样点的权重，为下载数据量的平方根

  public int weight;

  //当前采样点的下载速度

  public float value;

}

//参数有两个，分别是采样点的权重和下载速度

public void addSample(int weight, float value) {

  //确保采样点是按照index即时间顺序排序的

  ensureSortedByIndex();

  //如果回收区有采样点，直接复用即可；如果没有，则需要新建，这样能够一定程度地避免内存频繁申请与释放

  Sample newSample =

      recycledSampleCount > 0 ? recycledSamples[--recycledSampleCount] : new Sample();

  //相关信息的更新

  newSample.index = nextSampleIndex++;

  newSample.weight = weight;

  newSample.value = value;

  samples.add(newSample);

  totalWeight += weight;

  //这里是实现滑动窗口的部分，如果当前总权重超过了最大权重，就需要滑动窗口，保持窗口内的权重恒等于最大权重

  while (totalWeight > maxWeight) {

    //计算totalWeight与maxWeight的差值excessWeight

    int excessWeight = totalWeight - maxWeight;

    Sample oldestSample = samples.get(0);

    //如果最老采样点的权重小于excessWeight，直接删除

    if (oldestSample.weight <= excessWeight) {

      totalWeight -= oldestSample.weight;

      samples.remove(0);

      if (recycledSampleCount < MAX_RECYCLED_SAMPLES) {

        recycledSamples[recycledSampleCount++] = oldestSample;

      }

    //如果最老采样点的权重大于excessWeight，该点的权重减掉excessWeight

    } else {

      oldestSample.weight -= excessWeight;

      totalWeight -= excessWeight;

    }

  }

}

//只有一个参数，取值范围是(0,1]

public float getPercentile(float percentile) {

  //将采样点按照下载速度进行排序

  ensureSortedByValue();

  //算出要取的权重值desiredWeight

  float desiredWeight = percentile * totalWeight;

  int accumulatedWeight = 0;

  //遍历采样点，找到累加权重值大于等于desiredWeight的采样点，并返回该采样点的下载速度

  for (int i = 0; i < samples.size(); i++) {

    Sample currentSample = samples.get(i);

    accumulatedWeight += currentSample.weight;

    if (accumulatedWeight >= desiredWeight) {

      return currentSample.value;

    }

  }

  // Clamp to maximum value or NaN if no values.

  return samples.isEmpty() ? Float.NaN : samples.get(samples.size() - 1).value;

}