Gilbert Elliot丢包模型

 需要一个网络数据包传输的丢包模型，上代码。

p is the probability of transferring from Good State to the bad state 
and r is the probability of transferring from the bad state to the Good

bitmap.h

#include <stdint.h>
#include <cstdlib>
class BitMap{
public:
    BitMap(int bits);
    ~BitMap();
    void Init(int bits);
    void SetBit(char value);
    double LossRate();
private:
    char *buf_{nullptr};
    int cur_pos_{0};
    int bits_{0};
    int loss_n_{0};
    double lossrate_;
};

bitmap.cc

#include "bitmap.h"
#include <string.h>
BitMap::BitMap(int bits){
    Init(bits);
}
BitMap::~BitMap(){
    if(buf_){
        free(buf_);
    }
}
void BitMap::Init(int bits){
bits_=bits;
cur_pos_=0;
loss_n_=0;
int alloc=(bits_+sizeof(char)-1)/(sizeof(char));
buf_=(char*)malloc(alloc*sizeof(char));
memset(buf_,0,alloc*sizeof(char));
}
void BitMap::SetBit(char value){
    if(cur_pos_>=bits_){
        return;
    }
    int unit=sizeof(char);
    int index=cur_pos_/unit;
    int offset=cur_pos_%unit;
    char origin=buf_[index];
    char flag=0;
    if(value==1){
        flag=1<offset;
        origin+=flag;
        buf_[index]=origin;
    }
    if(value==0){
        loss_n_++;
    }
    cur_pos_++;
}
double BitMap::LossRate(){
    double loss_rate=0.0;
    double num=loss_n_;
    double den=cur_pos_;
    if(cur_pos_){
        loss_rate=num/den;
    }
    return loss_rate;
}

test_main.cc

#include <iostream>
#include <random>
#include <time.h>
#include "bitmap.h"
using namespace std;

int main()
{
    std::default_random_engine generator1(time(0));
    std::default_random_engine generator2;
    std::uniform_real_distribution<double> distribution1(0.0,1.0);
    std::uniform_real_distribution<double> distribution2(0.0,1.0);
    int total_packet=1000;
    double p = 0.02777;
    double r = 0.25;
    int i=0;
    char good=1;
    BitMap bitmap(total_packet);
    for(i=0;i<total_packet;i++){
        if(good==1){
            bitmap.SetBit(good);
            double random=distribution1(generator1);
            bool stay=random>p;
            good=stay;
        }else if(good==0){
            bitmap.SetBit(good);
            double random=distribution2(generator2);
            bool change=random>(1-r);
            good=change;
        }else{
        }
    }
    double theory_loss=1-(r)/(p+r);
    double actual_loss=bitmap.LossRate();
    std::cout <<theory_loss<<" "<<actual_loss<<std::endl;
    return 0;
}

 输出结果:

0.099  0.095

 尝试推导一下：

 图来自于[6]。其中，$r$是由状态B转移到G的概率，$p$是由状态G转移到B的概率，$(1-k)$是在状态G的丢包概率，$(1-h)$是在状态B的丢包概率。Gilbert-Elliot丢包模型是两个状态的markov链。markov链的转移矩阵
$$A=\left\{\begin{array}{cc}1-p& p\\ r& 1-r\end{array}\right\}$$
 当$n(0,1)，r\in (0,1)$时，markov链能够达到一个与初始状态无关的平稳分布（可以随便找相关的书翻一下），而在稳定状态，有 $\mathbf{\pi }A=\mathbf{\pi }$,其中$\mathbf{\pi }=({\pi }_G,{\pi }_B)$。${\pi }_G$是处在good状态的概率，${\pi }_B$是处在bad状态的概率，${\pi }_G+{\pi }_B=1$。
$$\begin{gathered} {\pi }_G(1-p)+{\pi }_{B}r={\pi }_G \\ {\pi }_{G}p+{\pi }_B(1-r)={\pi }_B \end{gathered}$$
 求出等式的解：
$$\begin{gathered} {\pi }_G=\frac{r}{r+p} \\ {\pi }_B=\frac{p}{p+r} \end{gathered}$$
 丢包概率$P_E={\pi }_G(1-k)+{\pi }_B(1-h)$。假设在good状态k=1,就是丢包概率是0，在bad状态h=0，全部丢包，就是代码中使用的理论丢包计算公式：
$P_E=1-r/(p+r)$。

[1] Generate Packet Loss Patters using Gilbert Elliot Model https://www.mathworks.com/matlabcentral/fileexchange/38554-generate-packet-loss-patters-using-gilbert-elliot-model
[2] KokoChannel https://github.com/JanValiska/KokoChannel
[3] 基于单向卫星网络的丢包模型及UDP数据抗干扰编码研究
[4] Networked state estimation over a Gilbert-Elliot type channel
[5] Definition of a general and intuitive loss model for packet networks and its implementation in the Netem module in the Linux kernel
[6] The Gilbert-Elliott Model for Packet Loss in Real Time Services on the Internet
[7] 阶层固化中的马尔可夫链 https://zhuanlan.zhihu.com/p/25437964