Promela BCL-6 B4.0 Protocol [Incomplete]

最新推荐文章于 2025-05-21 10:45:00 发布
最新推荐文章于 2025-05-21 10:45:00 发布
阅读量1.5k 收藏
点赞数 1
CC 4.0 BY-SA版权
分类专栏： 操作系统 文章标签： byte 数据结构 测试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/maray/article/details/1711956
本文介绍了一种使用PROMELA语言验证BCL可靠性协议的方法，该协议版本为4.0。通过采用集合点通信和队列自动重发机制，允许CHK、RTT、ACK、DATA等包丢失情况下的可靠传输。同时，模拟了传输介质特性，包括丢包、包失序及延迟阻塞。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

/*
* PROMELA Validation Model
* 协议层验证
*
* 验证BCL可靠性协议B version4.0
*
* Yuhuang
* 2007-7-27
*/





/*
* 本版本特点：采用集合点来通信,允许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*/

/* 消息类型定义 */
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;
/*
#define inc(x) (x=(x+1)%WIN)
*/

/* 接收方期望系列号 */
byte expected_seqno;




/* 进程说明：
 * 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 ->

        /* 不为空者逐个加一 */
        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 ->
                if
                ::rdata!msg[i].type,msg[i].version,msg[i].seqno ->
                    flag[i] = 0;
                ::skip
                fi            
            ::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 endofsend    /* 信息已经阻塞，无须发送 */
                
            ::else->    /* Msg[i]中已有一条消息,且不阻塞这条消息了 */
                if
                ::rdata!type,v,seq
                ::skip
                fi
            fi;
endofsend:        skip
        ::skip ->    /* 直接传递或丢弃数据包 */        
            if
            ::rdata!type,v,seq
            ::skip
            fi
        fi
    od
}


proctype receiver2media()
{
    byte seq;
    byte v;
    mtype type;
    
    do
    ::revts?type,v,seq ->
        if
        ::sevts!type,v,seq
        ::skip
        fi
    od
}



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

    byte s;
    byte version;
    byte rrt_version;
    
    head_seq = 0;
    tail_seq = 0;
    cur_seq = 0;
    
    rrt_version = 0; /* init rrt version number */
    
    do
    ::(tail_seq+WIN-head_seq+1)%WIN != QSIZE ->    /* 队列不为满，允许发送*/
        if
        ::sdata!DATA,0,cur_seq    /* normal send action */
        fi;
        
progress_2:    cur_seq=(cur_seq+1)%WIN;
        tail_seq=(tail_seq+1)%WIN;;    /* 更新tail,  head保持不变 */
    


    ::sevts?ACK,version,s ->
        /* 进行ACK失序处理 */
        /* 若s不在当前的head_seq~tail_seq范围内,则简单忽略之 */
        if
        ::(head_seq < tail_seq) ->    /*顺序递增情景 */
            if
            ::(s > tail_seq || s < head_seq ) ->
                goto endofack
            ::else
            fi
        ::(head_seq > tail_seq) ->    /* 非递增情景 */
            if
            ::( s < head_seq && s > tail_seq ) ->
                goto endofack
            ::else
            fi
        ::else ->    /* 队列为空  */
            goto endofack    /* 此ACK是在介质中被延迟了的ACK, 简单丢弃之 */
        fi;
        
        assert(s<WIN);
        head_seq = (s + 1)%WIN;    /* 根据ACK更新head_seq,暗含了累积更新 */
        cur_seq = head_seq;
        
endofack:    skip
        
    ::sevts?RRT,version,s ->
        if
        ::(version == rrt_version) ->    /* 预期rrt*/
            /* 将发送链上s(eqno)之前的数据都摘除 */
            /*发送链上 s之后的所有数据都重发,rrt_version加1  */
            
            head_seq = s;    /* 注意:  由于是响应 RRT消息,不要写成了head_seq =(s + 1)%WIN */
            cur_seq = head_seq;    /* 调整发送指针,准备重发 */
            
            rrt_version = (rrt_version + 1) % WIN    /* inc(rrt_version); */
            
        :: else ->    /* 接受到非预期rrt */
            skip    /* 简单丢弃之 */
        fi
    
    ::((cur_seq != tail_seq) && (tail_seq - head_seq) != 0 ) ->    
    /* 队列不为空，允许发送. 此情景配合timeout时重发使用 */                                    
    /* 第一个判断是为了防止发送不存在内容 */
        if
        ::sdata!DATA,0,cur_seq    /* normal send action */
        fi;        
        cur_seq=(cur_seq+1)%WIN;    
        
        
    ::timeout ->    /* 超时 */
        sdata!CHK,rrt_version,head_seq; /* 超时,发CHK消息,查询是否需要重发 */
    od
}



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

    byte s;
    byte v;
    
    do
    ::rdata?CHK,v,s ->    /*收到CHK消息*/
        if
        ::(s == expected_seqno) ->    /* chk检查的数据包即为接收方期望的数据包 */
            revts!RRT,v,s    /* 直接返回RRT消息 */


        ::( ( s < expected_seqno && expected_seqno-s < WIN/2 ) ||
            (  s > expected_seqno && s-expected_seqno > WIN/2) ) ->    /* 小于期望包号,ACK之 */
            revts!ACK,0,(expected_seqno+WIN-1)%WIN

            
        ::else ->    /* CHK检查消息错,系统出错 */
            printf("s=%d exp=%d ",s,expected_seqno);
            assert(false)
        fi


    ::rdata?DATA,v,s ->    /* 收到DATA消息,s为消息序列号 */
        /* s 与expected_seqno在队列中前后关系的判断: 
        
        1. if  ( s > expected_seqno && s-expected_seqno < WIN/2 )  or    *normal
                 (  s < expected_seqno && expected_seqno-s > WIN/2) then 
            s'>'expected_seqno            -- 收到的消息(s)排在期待数(expected_seqno)的后面
            
        2. if  ( s < expected_seqno && expected_seqno-s < WIN/2 )  or    *normal
                 (  s > expected_seqno && s-expected_seqno > WIN/2) then 
            s'<'expected_seqno            -- 收到的消息排在期待数的前面 

        3. if( s==expected_seqno ) then
            s'=='expected_seqno            -- 收到的消息等于期待的数 
        */
        if
        ::( ( s > expected_seqno && s-expected_seqno < WIN/2 ) ||
            (  s < expected_seqno && expected_seqno-s > WIN/2) ) ->        /*大于*/
            /* 在存在丢包的流水环境下，这种情况是完全会出现的，不应该看作系统严重错误*/
            /*assert(false)    *//* 非预期消息,系统严重错误 */
            
            /* Yuhuang的方案（2007-7-27）：
            简单忽略之
            */
            skip
        ::( s == expected_seqno) ->                        /*等于*/
            revts!ACK,0,expected_seqno;
            expected_seqno = (expected_seqno+1)%WIN
                    
        :: else ->                                /*小于*/
            revts!ACK,0,(expected_seqno+WIN-1)%WIN
            
        fi
            
    od
            

    
}


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

}
【SPIN】PROMELA数据与程序结构详解（SPIN学习系列--7）
05-20 1059
PROMELA是一种专为系统建模设计的语言，主要用于通过状态空间搜索验证系统正确性。其模型通常较小，但行为复杂，依赖SPIN进行模型检查。PROMELA不支持函数、类等高级结构，而是通过数组、类型定义、宏和内联声明来组织数据和代码。数组仅支持一维，可通过循环或非确定性方式初始化；类型定义用于创建复合类型，如消息结构或模拟多维数组；预处理器支持文件包含、宏定义和条件编译；内联声明则用于代码重用，类似于宏但语法更友好。这些特性使PROMELA能够有效建模复杂并发系统，但需注意数组越界、内存占用和文本替换的副作用
【SPIN】PROMELA语言编程入门同步机制（SPIN学习系列--4）
05-19 880
PROMELA模型语言通过语句的可执行性和阻塞条件实现同步机制，避免了信号量、锁等显式同步原语的复杂性。文章详细介绍了阻塞式同步、状态转移图、原子语句序列、信号量模拟、非确定性建模以及进程终止与死锁检测等内容。PROMELA通过原子操作和条件阻塞实现互斥，状态转移图帮助验证互斥性和检测死锁。信号量可以通过原子操作模拟，而非确定性选择则用于覆盖所有可能的执行路径。SPIN验证工具链是分析并发系统的核心手段，确保模型在各种情况下的正确性。
Promela BCL-6 A Protocol
sabolasi
07-26 274
/**PROMELAValidationModel*协议层验证**验证BCL可靠性协议Aversion5.0**Yuhuang*2007-7-26*//**本版本特点：采用集合点来通信,允许ACK、DATA丢包，实现了队列自动重发。*加入了对传输介质的模拟。介质可以丢包，导致包失序。**未完全模拟的问题：ACK、DATA失序问题*//**************数据结构定义*********...
Promela轻松入门教程
大鹌鹑咕咕咕
10-10 1万+
最近在学并发开发, 里面需要用到Promela语言来检测代码的逻辑 Promela用起来很麻烦, 不过网上有个GUI
PROMELA语言描述 协议分析（停等，AB）报告
06-17
本文档包含停止等待协议以及AB协议的PROMELA语言描述，帮助我们理解上述两个协议有很大的帮助。
Traffic-Lights-Promela
06-09
【标题】"Traffic-Lights-Promela"是一个关于交通灯模拟的项目，它使用了Promela语言，这是SPIN模型检查器的一种建模语言。在软件验证与验证技术（SVVT）领域，这样的项目通常用于设计和分析系统的行为，确保其在...
论文研究-Protocol Security Testing with SPIN and TTCN-3.pdf
08-16
它支持 PROMELA（一种过程模型语言）进行协议描述，并提供了诸如死锁检测、状态空间搜索优化和模型简化等功能。 TTCN-3（Tree and Tabular Combined Notation）是一种国际标准的测试语言，主要用于通信协议的测试。...
【SPIN】PROMELA 通道（Channels）（SPIN学习系列--8）
最新发布
05-21 595
通道是分布式系统建模中的核心组件，用于模拟进程间的消息传递。PROMELA 中的通道支持发送和接收操作，分为同步通道和缓冲通道。同步通道要求发送方和接收方同时就绪，适用于严格的请求-响应场景；缓冲通道则允许消息暂存，支持异步通信，适用于高并发场景。通道的声明、初始化、发送与接收操作均有特定语法，且支持高级功能如随机接收、有序发送、消息复制和轮询接收。选择通道类型时需根据通信模式、状态空间和适用场景进行权衡。
并发系统的Promela语言建模与SPIN模型检测
12-16
并发系统的Promela语言建模与SPIN模型检测
并发系统Promela建模、SPIN的使用
05-19
并发系统Promela语法规则，并发系统建模和SPIN的使用
spin和promela简介
04-08
对spin和promela做了个简单总结，还有些简单例子
论文阅读——《Model Checking Turotial Overview》
swallowblank的博客
04-13 874
reactive system：反应性系统 in 第一章 模型检查。一个总览教程。 摘要 我们调查了反应系统自动分析的模型检验技术原理。通过对Needham-Schroeder公钥协议的分析来举例说明模型检查的使用。 然后，我们正式定义过渡系统，时间逻辑，ω-自动机及其关系。 定义了线性和分支时间时序逻辑的基本模型检查算法，然后介绍了符号模型检查和偏序约简技术。 本文以一些更高级主题的参考列表结尾...
Spin和Promela复习
czl_Lynn的博客
08-07 2176
并发系统的Promela语言建模与SPIN model checker promela:https://blog.csdn.net/xlrtx/article/details/39971051 spin:https://blog.csdn.net/ganggexiongqi/article/details/5794293
spin简介以及ispin运行样例
fbj_bai的博客
10-26 5402
工具名称：iSpin 工具的适用范围和应用情况：此工具主要是用Promela编写实现。Promela是一种过程建模语言，其预期用途是验证并行系统的逻辑。给定Promela中的程序，Spin可以通过对建模系统的执行进行随机或迭代仿真来验证模型的正确性，或者可以生成C该程序对系统状态空间进行快速详尽的验证。验证程序还可以用于证明系统不变性的正确性，并且可以找到非进度执行周期。最后，它支持线性时间时间...
协议的验证
Troy
12-18 3813
协议的验证一、实验课程内容和基本要求（一） 试验设备与工具软件（上机环境与工具软件）（二）具体内容（三）基本要求实验内容实验一：使用停等协议一、实验目的二、实验原理三、实验仪器四、实验内容及步骤代码实现对协议进行修改Spin 验证实验二 AB协议一、实验目的二、实验原理三、实验仪器代码实现Spin 验证五. 验证结果:实验三 Go-Back-N协议一、实验目的二、实验原理三、实验仪器四、实验内容...
STREAM Benchmark及其操作性能分析
热门推荐
余璜的技术博客
03-08 3万+
STREAM Benchmark及其操作性能分析文/raywill     STREAM 是业界广为流行的综合性内存带宽实际性能 测量 工具之一。随着处理器处理核心数量的增多，内存带宽对于提升整个系统性能越发重要，如果某个系统不能够足够迅速地将内存中的数据传输到处理器当中，若干处理核心就会处于等待数据的闲置状态，而这其中所产生的闲置时间不仅会降低系统的效率还会抵消多核心和高主频所带来的性能提升因素。 STREAM 具有良好的空间局部性，是对 TLB 友好、Cache友好的一款测试。STREAM支持
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值