验证BCL可靠性协议C version1.0[Incomplete]

/*
* PROMELA Validation Model
* 协议层验证
*
* 验证BCL可靠性协议C version1.0
*
* Yuhuang
* 2007-7-29
*/





/*
* 本版本特点：采用集合点来通信,允许CHK、RTT、ACK、DATA丢包，实现了队列自动重发。
*    加入了对传输介质的模拟。介质可以丢包，导致包失序。
*    加入了对传输介质中存在延迟阻塞的模拟。包可以失序。
*    加入对接收方向发送方的失序模拟。 
*     CHK的语义实现
*
*/






/*
* 测试记录： 
* WIN=5 QSIZE=2 跑了大约_秒钟
* WIN=7 QSIZE=3 跑了大约_分钟
* WIN=9 QSIZE=4 ???
*/





/************** 数据结构定义 *************/


/* 序号范围定义 */
#define WIN 7
/* 发送队列大小定义 */
#define QSIZE 3
/*Note:上面是比较保险的做法: WIN = QSIZE * 2 + 1*/

/*
#define inc(x) (x=(x+1)%WIN)
*/

/* 消息类型定义 */
mtype = { ACK,DATA,RRT,CHK }


/* 
 * { ACK|RRT,res|version, seqno }
 */
chan sevts = [0] of { mtype,byte,byte };
chan revts = [0] of { mtype,byte,byte };


/*
 * { DATA|CHK, res|version, seqno} 
 * 数据队列 
 */
chan sdata = [0] of { mtype,byte,byte };
chan rdata = [0] of { mtype,byte,byte };

/*
 * 为实现阻塞模拟，需要定义复合类型数组
 */
typedef Msg{
    mtype type;
    byte version;
    byte seqno;
};


/* 发送记录队列 */
/* 当ACK发生的时候，ACK（含）之前的内容都被清除 */
byte head_seq;
byte tail_seq;
byte cur_seq;

/* 发送队列元素状态标志 */
bool sflag[WIN];    /* = 0，已确认；=1，未确认  */
/* 发送窗口的范围是由head_seq和QSIZE一起决定的 */
/* Avaliable Range： head_seq ~ head_seq+QSIZE-1 */


/* 接收方期望系列号 */
byte expected_seqno;
/* 接收方窗口 */
/* min , max */
byte min_seq;
byte max_seq;
byte rseqno;    /* recv seqno */
/* 未收到消息记录链 */
bool rflag[WIN];    /* =1表示未收到， =0 表示已经收到*/


/* 进程说明：
 * 1. sender2media    发送方到接收方的介质模拟进程
 * 2. receiver2media     接收方到发送方的介质模拟进程
 * 3. sender        发送方进程
 * 4. receiver        接收方进程
 */

proctype sender2media()
{
    byte seq;
    byte v;
    mtype type;
    
    /* 阻塞队列 */
    Msg msg[QSIZE];
    /* flag语义：
     *     flag[i] = 0的时候，表示msg[i] 为空
     *     flag[i]  = m (m>0) 的时候，表示从msg[i]被阻塞以来，没有被阻塞的包的个数为m
     * flag用法：
     *     （1）每次收到一个消息，将不为零的flag[i]逐个加一
     *    （2）发现某个flag[i] 的值大于等于QSIZE时必须将其从阻塞队列中取出，进行发送或丢弃，转4
     *    （3）随机选择一个不为空的阻塞Msg，将其从阻塞队列中取出，进行发送或丢弃
     *    （4）flag子序列结束
    */
    byte flag[QSIZE];    
    byte i;    /* 记录随机数下标用 */
    byte j;    /* 产生随机数用 */
    
    
    do
    ::sdata?type,v,seq ->
        /* CHK语义实现 */
        
        /*CHK的完整语义为:
        检查CHK携带的seqno之前(含)的数据包是否发送到位.通过硬件相关技术，
        它可以严格保证在CHK发出之前的所有数据包都已经丢失或者到达，
        而不会存在某个数据包因为延迟而后于CHK包到达。
        */
        i=0;
        j=0;
        if
        ::(type==CHK) ->
            do
            :: i < QSIZE ->
                if
                ::flag[i] != 0 ->    /*当前Msg为一个不为空的阻塞Msg*/
                    if    /* 随机选择是发送还是丢弃 */
                    ::rdata!msg[i].type,msg[i].version,msg[i].seqno    /* 发送 */
                    ::skip    /*丢弃 */
                    fi;
                    flag[i] = 0;    /* 标记当前消息槽可用 */
                ::else 
                fi;
                i = i + 1;
            :: else break
            od;            
        ::else ->skip
        fi;
/*======================================================*/    
        /* 阻塞语义实现 */
        
        /* 不为空者逐个加一 */
        i = 0;
        j = 0;    
        do
        :: i < QSIZE ->
            if
            ::flag[i] != 0 ->
                flag[i] = flag[i] + 1
            ::else -> skip
            fi;
            i = i + 1
        :: else break
        od;
        /*寻找需要立即处理的Msg */
        i = 0;
        j = 0;
        do
        :: i < QSIZE ->
            if
            ::(flag[i] == QSIZE-1) ->
                if
                ::rdata!msg[i].type,msg[i].version,msg[i].seqno->    /* 立即发送,否则模拟的网络存在重大错误 */
                    flag[i] = 0
                fi
            ::else -> skip
            fi;
            i = i + 1;
        :: else break
        od;    
        /* 随机选择一个不为空的阻塞Msg，将其从阻塞队列中取出，进行发送或丢弃*/
        i = 0;
        j = 0;
        do
        :: i < QSIZE ->
            if
            ::flag[i] != 0 ->    /*选择到一个不为空的阻塞Msg*/
                if    /* 随机选择是发送还是丢弃 */
                ::rdata!msg[i].type,msg[i].version,msg[i].seqno    /* 发送 */
                ::skip    /*丢弃 */
                fi;                
                flag[i] = 0;    /* 标记当前消息槽可用 */
                break;
            ::skip
            fi;
            i = i + 1
        :: else break
        od;

/*======================================================*/

        /* 阻塞模块的任务已经完成, 现在处理当前消息 -- 阻塞它或者传递它! */
        
        /* 阻塞或传递当前的数据包 */
        i=0;
        j=0;
        if
        ::skip ->    /* 阻塞这个数据包*/
            /* 随机选择一个空位 */
            do
            ::j>=0 ->
                j = (j + 1) % QSIZE
            ::skip ->
                i = j;        /*获得随机数 */
                break    
            od;

            if
            ::flag[i]==0 ->    /*Msg[i]为空，可以放下一条阻塞消息*/
                msg[i].type = type;
                msg[i].version = v;
                msg[i].seqno = seq;
                flag[i] = 1;    /*标记Msg[i] 中已经存有消息*/
                goto endofsend1    /* 信息已经阻塞，无须发送 */
                
            ::else->    /* Msg[i]中已有一条消息,且不阻塞这条消息了 */
                if
                ::rdata!type,v,seq
                ::skip
                fi
            fi;
endofsend1:        skip
        ::skip ->    /* 直接传递或丢弃数据包 */        
            if
            ::rdata!type,v,seq
            ::skip
            fi
        fi
    od
}


proctype receiver2media()
{
    byte seq;
    byte v;
    mtype type;
    
    /* 阻塞队列 */
    Msg msg[QSIZE];
    /* flag语义：
     *     flag[i] = 0的时候，表示msg[i] 为空
     *     flag[i]  = m (m>0) 的时候，表示从msg[i]被阻塞以来，没有被阻塞的包的个数为m
     * flag用法：
     *     （1）每次收到一个消息，将不为零的flag[i]逐个加一
     *    （2）发现某个flag[i] 的值大于等于QSIZE时必须将其从阻塞队列中取出，进行发送或丢弃，转4
     *    （3）随机选择一个不为空的阻塞Msg，将其从阻塞队列中取出，进行发送或丢弃
     *    （4）flag子序列结束
    */
    byte flag[QSIZE];    
    byte i;    /* 记录随机数下标用 */
    byte j;    /* 产生随机数用 */
    
    
    do
    ::revts?type,v,seq ->    /* 从receiver方接到消息 */

        /* 不为空者逐个加一 */
        i = 0;
        j = 0;    
        do
        :: i < QSIZE ->
            if
            ::flag[i] != 0 ->
                flag[i] = flag[i] + 1
            ::else -> skip
            fi;
            i = i + 1
        :: else break
        od;
        /*寻找需要立即处理的Msg */
        i = 0;
        j = 0;
        do
        :: i < QSIZE ->
            if
            ::(flag[i] == QSIZE-1) ->
                if
                ::sevts!msg[i].type,msg[i].version,msg[i].seqno->    /* 立即发送,否则模拟的网络存在重大错误 */
                    flag[i] = 0
                fi
            ::else -> skip
            fi;
            i = i + 1;
        :: else break
        od;    
        /* 随机选择一个不为空的阻塞Msg，将其从阻塞队列中取出，进行发送或丢弃*/
        i = 0;
        j = 0;
        do
        :: i < QSIZE ->
            if
            ::flag[i] != 0 ->    /*选择到一个不为空的阻塞Msg*/
                if    /* 随机选择是发送还是丢弃 */
                ::sevts!msg[i].type,msg[i].version,msg[i].seqno    /* 发送 */
                ::skip    /*丢弃 */
                fi;
                flag[i] = 0;    /* 标记当前消息槽可用 */
                break;
            ::skip
            fi;
            i = i + 1
        :: else break
        od;


        /* 阻塞模块的任务已经完成, 现在处理当前消息 -- 阻塞它或者传递它! */
        
        /* 阻塞或传递当前的数据包 */
        i=0;
        j=0;
        if
        ::skip ->    /* 阻塞这个数据包*/
            /* 随机选择一个空位 */
            do
            ::j>=0 ->
                j = (j + 1) % QSIZE
            ::skip ->
                i = j;        /*获得随机数 */
                break    
            od;

            if
            ::flag[i]==0 ->    /*Msg[i]为空，可以放下一条阻塞消息*/
                msg[i].type = type;
                msg[i].version = v;
                msg[i].seqno = seq;
                flag[i] = 1;    /*标记Msg[i] 中已经存有消息*/
                goto endofsend2    /* 信息已经阻塞，无须发送 */
                
            ::else->    /* Msg[i]中已有一条消息,且不阻塞这条消息了 */
                if
                ::sevts!type,v,seq
                ::skip
                fi
            fi;
endofsend2:        skip
        ::skip ->    /* 直接传递或丢弃数据包 */        
            if
            ::sevts!type,v,seq
            ::skip
            fi
        fi
    od

}



/*
* 发送方
* 发送两类消息: DATA(数据) 、CHK( 缓冲区可用性检查) 
* 
* 接受两类消息: ACK( 确认) 、RRT(请求重传) 
*/
proctype sender()
{

    byte s;
    byte version;
    int rrt_version;

    byte i;
    byte j;
    
    /* 发送队列*/
    Msg sbuf[WIN];    /* 为了方便，不使用QSIZE。实际上，某个时刻起作用的个数仍然为QSIZE个 */

    
    /* 假设第0个包已经发出 */
    head_seq = 0;
    tail_seq = 0;
    sflag[0] = 1;
    
    cur_seq = 0;    /*定位发送点 */
    
    rrt_version = 0; /* init rrt version number */
    
    
    do
    ::(tail_seq+WIN-head_seq+1)%WIN < QSIZE ->    /** 队列不为满 （没有超出窗口范围），允许加入新的待发消息 **/
        /*加入一个元素到发送队列中 */
progress_2:    tail_seq = (tail_seq + 1)%WIN;/* 更新tail,  head保持不变 */
        sflag[tail_seq] = 1;
        /* 立即发送之 */
        sdata!DATA,0,tail_seq;    /* try to send now! */

        
    ::sevts?ACK,version,s ->            /** 接收到ACK **/
        /* 无须进行ACK失序处理 */
        assert(s<WIN);
        /* ACK的时候需要检查是否可以向前滑动窗口（这里头变尾不变） */
        i=s;
        sflag[i] = 0;    /* 标志sflag[s] 已经确认 */
        if
        ::i==head_seq ->    /*可以滑动，至少一格，多则数格 */
            do
            ::sflag[i]==0 ->    /* 此元素已经确认 */
                i = (i + 1)%WIN;
            ::else ->
                /* 将队列前面连续的都确认了的消息从窗口范围内删除。*/
                head_seq = i; /* got new head，此时do的第一个分支又可以工作了 */
                break;
            od
        ::else
        fi
        
        
        
    ::sevts?RRT,version,s ->            /** 接收到RRT **/
        if
        ::(version == rrt_version) ->    /* 预期rrt*/
            /*重发s,rrt_version加1  */
            sdata!DATA,0,i;
            rrt_version = (rrt_version + 1) % WIN;    /* inc(rrt_version); */
            
        :: else ->    /* 接受到非预期rrt */
            skip    /* 简单丢弃之 */
        fi
    
    ::timeout ->    /* 超时 */
        /* 扫描发送队列，找到第一个可以发送的消息，对其发出CHK */
        i = head_seq;
        j = tail_seq;
        do
        :: i <= tail_seq ->
            if
            ::(sflag[i] == 1) ->
                sdata!CHK,rrt_version,i;
                break;
            ::else -> skip
            fi;
            i = (i + 1)%WIN;
        :: else ->        
            break;
        od;
    od
}



/*
* 接收方
* 发送两类消息: ACK( 确认) 、RRT(请求重传) 
* 
* 接受两类消息: DATA(数据) 、CHK( 缓冲区可用性检查) 
*/
proctype receiver()
{


    byte v;

    
    /* 假设0号消息已经收到 */
    max_seq = 0;
    min_seq = 0;
    rflag[0] = 0;
    
    do
    ::rdata?CHK,v,rseqno ->    /** 收到CHK消息 **/
        if
        ::((min_seq+WIN-rseqno-1)%WIN < WIN/2) ->        /* seqno < min_seqno */
            revts!ACK,v,rseqno;
        ::((rseqno-max_seq+WIN-1)%WIN < WIN/2) ->        /* Seqno > max_seqno */
            revts!RRT,v,rseqno;
        ::else                        /*  min_seqno < seqno < max_seqno */
            /*检查s是否已经接收到*/
            if
            ::rflag[rseqno]==1 ->    /*未收到*/
                revts!RRT,v,rseqno;
            ::else ->    /*已收到*/
                revts!ACK,v,rseqno;
            fi
        fi



    ::rdata?DATA,v,rseqno ->    /** 收到DATA消息,s为消息序列号 **/
        if
        ::((rseqno-min_seq+WIN-1)%WIN < WIN/2 && (max_seq-rseqno+WIN-1)%WIN < WIN/2) ->    /* s在二者之间 */
            rflag[rseqno] = 0;    /* 标志为已经收到*/
            revts!ACK,v,rseqno;
            /* 尝试更新 min_seq */
            rseqno=min_seq;
            do
            ::rflag[rseqno]==0 ->
                if
                /*::error  (max_seq-rseqno+WIN-1)%WIN < WIN/2 ->*/
                ::(max_seq-rseqno+WIN)%WIN <= WIN/2 ->
                    rseqno = (rseqno + 1)%WIN;
                ::else -> break;
                fi
            ::else ->
                break;
            od;
            
            min_seq = rseqno-1;
            
        ::((rseqno-max_seq+WIN-1)%WIN <= WIN/2) ->        /* seqno > max_seqno */
            /* 将max_seq到s之间的数据全部标记为未收到 */
            do
            ::max_seq < rseqno ->
                max_seq = (max_seq + 1)%WIN;
                rflag[max_seq] = 1;    /*标记未收到*/
            ::else ->
                break;
            od;
            rflag[max_seq]  = 0;    /* max_seq已经更新成了s，标记为已经收到 */
        ::else ->    /* seqno = max_seqno || seqno <= min_seqno */
            assert(false && 1==0);    /* deadly fault *//*收到重复消息*/
        fi        
    od
}


/* Promela入口程序 */
init
{
    atomic{
    run sender();
    run sender2media();
    run receiver();
    run receiver2media();
    }

}