【原创】Verilog实现常见数据结构计划（二）栈

最新推荐文章于 2024-05-08 00:07:15 发布
最新推荐文章于 2024-05-08 00:07:15 发布
阅读量1.9k 收藏 15
点赞数 4
分类专栏： # FPGA 文章标签： 缓存 verilog
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40807206/article/details/120460428
版权

文章目录

一、栈的 C 语言实现

1.1 顺序栈的结构定义

data为栈中每个元素的数据值；top为栈顶的指针，在计算机体系中也称作 sp 指针。

/* 数据结构定义 */
typedef struct
{
    int data[MAXSIZE];  // 栈数据空间
    int top;            // 栈顶指针
}SqStack;   // 顺序栈

1.2 顺序栈的初始化

在栈中，我们定义 sp 指针初始指向-1 ，表示这是一个空栈，而当 sp 指向 0 时则代表栈中存有一个数据。

// 栈初始化
void Stack_Init(SqStack *S)
{
    S->top = -1;
    for (unsigned int i = 0; i < MAXSIZE; i++)
        S->data[i] = 0;
}

1.3 顺序栈的写入

向栈中写入数据又称压栈或入栈，在将新数据压栈之前需要判断栈是否已经写满，方法是当 sp 指针指向栈空间的最顶端时则认为栈已满。若栈未满，则将 sp 指针自增以指向下一个存储单元，然后将数据存入这个存储单元。

// 压栈操作
char Push(SqStack *S, int e)
{
    if( S->top == MAXSIZE - 1 )
    {
        return -1;          // 栈满
    }

    S->top++;               // 栈顶自增
    S->data[S->top] = e;    // 数据e压栈
    return 1;
}

1.4 顺序栈的读出

从栈中读出数据又称弹栈或出栈，在执行读数据操作之前需要判断栈是否已经读空，方法是当 sp 指针指回 -1 时认为栈已经读空。若栈未空，则先读出当前 sp 指针指向空间的数据，然后将 sp 指针自减，指向上一个存储单元。

// 弹栈操作
char Pop(SqStack *S, int *e)
{   
    if( S->top == -1 )
    {
        return -1;          // 栈空
    }

    *e = S->data[S->top];   // 弹出的数据赋值给e
    S->top--;               // 栈顶自减
    return 1;
}

二、栈的 Verilog 实现

堆栈是现代计算机设备不可或缺的组成部分之一，局部变量、跳转语句、函数跳转的现场保存等，都需要使用堆栈（栈）来实现。目前主流的计算机及嵌入式处理器大都采用内存实现堆栈的方式，即在主存中开辟一块空间来保存堆栈数据。然而在一些低端嵌入式微控制器，例如 PIC 单片机中则会使用硬件堆栈，因为它们的内存不够大而且对堆栈大小的需求也不高。

基于上述的软件堆栈原理，本节使用 Verilog HDL 实现硬件同步堆栈并给出仿真测试。

2.1 Verilog 实现代码

以下为栈缓存的 verilog 实现代码。

① sp 指针在空栈时为 -1 （补码形式），并且约束其在栈顶和栈底的自增条件。
② 栈的判满和判空使用两个一段状态机实现。
③ 参数WRITE_GUARD可配置此栈缓存为写满保护或无写满保护模式。写满保护模式即是当栈满后，再将新数据压栈时不会将栈顶的旧数据冲刷掉。WRITE_GUARD = "ON"时打开写满保护、WRITE_GUARD = "OFF"时关闭写满保护。

//**********************************************
//COPYRIGHT(c)2021, XXX University
//All rights reserved.
//
//File name     : Sync_Stack.v
//Module name   : Sync_Stack	
//Full name     :
//Author 		: XXX
//Email 		: 
//
//Version 		:
//This File is  Created on 2021-09-24 13:27:27
//------------------Discription-----------------
//
//----------------------------------------------
//-------------Modification history-------------
//Last Modified by 	: XXX
//Last Modified time: 2021-09-24 13:27:27
//Discription 	:
//----------------------------------------------
//TIMESCALE
`timescale 1ns/1ns
//DEFINES
//`include ".v"
//----------------------------------------------

/*** 硬件堆栈 LIFO ***/ 
module Sync_Stack #(
	parameter	WRITE_GUARD =   "ON" ,	// 模式配置：“ON”开启栈顶写保护； “OFF”关闭写保护
	parameter	DATA_WIDTH	=	32   ,	// 数据位宽
	parameter	STACK_WIDTH =	8 	  	// log2(堆栈大小)
)
(
	input							sclk	,	// 同步时钟
	input							rst_n	,	// 低复位

	input							wr_en	,	// 写使能
	input		[DATA_WIDTH-1:0]	din		,	// 写数据
	output reg						full	,	// 写满标志

	input							rd_en	,	// 读使能
	output reg	[DATA_WIDTH-1:0]	dout	,	// 读数据
	output reg						empty 		// 读空标志
);


localparam	STACK_DEPTH = 	2**STACK_WIDTH;


reg		[DATA_WIDTH-1:0]	syc_ram	[STACK_DEPTH-1:0];	// RAM
reg		[STACK_WIDTH:0]	sp;								// SP指针
wire	[STACK_WIDTH:0]	index = $signed(sp) + 1;		 // ram元素索引


// RAM读写控制
generate
	// 堆栈写满保护模式
	if( WRITE_GUARD == "ON" ) begin
		reg	guard_flag;	// 栈顶写满保护标志
		always @(posedge sclk or negedge rst_n) begin : wr_rd
			integer i;
			if ( rst_n == 1'b0 ) begin
				for( i=0; i<STACK_DEPTH; i=i+1 )
					syc_ram[i] <= 'd0;
				dout <= 'd0;
				guard_flag <= 1'b0;
			end
			else begin
				if( wr_en & rd_en ) begin
					dout <= din;
					guard_flag <= 1'b0;
				end
				else if( wr_en && (index < STACK_DEPTH) ) begin
					if( index < (STACK_DEPTH - 1) ) begin
						syc_ram[index] <= din;
					end
					else begin
						if( guard_flag == 1'b0 ) begin
							syc_ram[index] <= din;
							guard_flag <= 1'b1;
						end
					end
				end
				else if( rd_en ) begin
					dout <= syc_ram[index];
					guard_flag <= 1'b0;
				end
			end
		end
	end
	// 无写满保护模式
	else begin
		always @(posedge sclk or negedge rst_n) begin : wr_rd
			integer i;
			if ( rst_n == 1'b0 ) begin
				for( i=0; i<STACK_DEPTH; i=i+1 )
					syc_ram[i] <= 'd0;
				dout <= 'd0;
			end
			else begin
				if( wr_en & rd_en ) begin
					dout <= din;
				end
				else if( wr_en && (index < STACK_DEPTH) ) begin
					syc_ram[index] <= din;
				end
				else if( rd_en ) begin
					dout <= syc_ram[index];
				end
			end
		end
	end
endgenerate


// SP指针控制
always @(posedge sclk or negedge rst_n) begin
	if ( rst_n == 1'b0 ) begin
		sp <= -1;
	end
	else begin
		if( wr_en & rd_en ) begin
			sp <= sp;
		end
		else if( wr_en && (index < STACK_DEPTH - 1) ) begin
			sp <= sp + 1'b1;
		end
		else if( rd_en && (index > 'd0) ) begin
			sp <= sp - 1'b1;
		end
		else begin
			sp <= sp;
		end
	end
end


// 栈满判断状态机
reg	full_state;
always @(posedge sclk or negedge rst_n) begin
	if ( rst_n == 1'b0 ) begin
		full_state <= 1'b0;
		full  <= 1'b0;
	end
	else begin
		case( full_state )
			// 未满状态
			1'b0 : begin
				if( wr_en && (index == STACK_DEPTH - 1) ) begin
					full  <= 1'b1;
					full_state <= 1'b1;
				end
				else begin
					full  <= 1'b0;
					full_state <= 1'b0;
				end
			end

			// 栈满状态
			1'b1 : begin
				if( rd_en ) begin
					full  <= 1'b0;
					full_state <= 1'b0;
				end
				else begin
					full  <= 1'b1;
					full_state <= 1'b1;
				end
			end
		endcase
	end
end


// 栈空判断状态机
reg empty_state;
always @(posedge sclk or negedge rst_n) begin
	if ( rst_n == 1'b0 ) begin
		empty_state <= 1'b1;
		empty <= 1'b1;
	end
	else begin
		case( empty_state )
			// 未空状态
			1'b0 : begin
				if( rd_en && (index == 'd0) ) begin
					empty  <= 1'b1;
					empty_state <= 1'b1;
				end
				else begin
					empty  <= 1'b0;
					empty_state <= 1'b0;
				end
			end

			// 栈空状态
			1'b1 : begin
				if( wr_en ) begin
					empty  <= 1'b0;
					empty_state <= 1'b0;
				end
				else begin
					empty  <= 1'b1;
					empty_state <= 1'b1;
				end
			end
		endcase
	end
end


endmodule

2.2 仿真测试

Testbench 代码如下所示。

//**********************************************
//COPYRIGHT(c)2021, XXX University
//All rights reserved.
//
//File name     : testbench.v
//Module name   : testbench	
//Full name     :
//Author 		: XXX
//Email 		: 
//
//Version 		:
//This File is  Created on 2021-09-24 13:27:08
//------------------Discription-----------------
//
//----------------------------------------------
//-------------Modification history-------------
//Last Modified by 	: XXX
//Last Modified time: 2021-09-24 13:27:08
//Discription 	:
//----------------------------------------------
//TIMESCALE
`timescale 1ns/1ns
//DEFINES
//`include ".v"
//----------------------------------------------


`define DATA_WIDTH		32
`define STACK_WIDTH		4

module testbench;

reg							sclk   ;
reg							rst_n  ;
  
reg							wr_en  ;
reg		[`DATA_WIDTH-1:0]	din    ;
wire						full   ;
  
reg							rd_en  ;
wire 	[`DATA_WIDTH-1:0]	dout   ;
wire						empty  ;


// 生成时钟
initial begin
	sclk = 0;
	forever #5 sclk = ~sclk;
end


// Main
initial begin
	rst_n = 0;
	wr_en = 0;
	din = 0;
	rd_en = 0;
	#50
	rst_n = 1;

	#50
	repeat( 2**`STACK_WIDTH + 1 ) begin
		@(posedge sclk) begin
			wr_en <= 1'b1;
			din   <= din + 1;
		end
	end

	@(posedge sclk)
		wr_en <= 1'b0;


	repeat( 2**`STACK_WIDTH + 1 ) begin
		@(posedge sclk) begin
			rd_en <= 1'b1;
		end
	end

	@(posedge sclk)
		rd_en <= 1'b0;




	#50
	repeat( 2**`STACK_WIDTH/2 ) begin
		@(posedge sclk) begin
			wr_en <= 1'b1;
			din   <= din + 1;
		end
	end

	@(posedge sclk)
		wr_en <= 1'b0;

	#50
	repeat( 2**`STACK_WIDTH/2 ) begin
		@(posedge sclk) begin
			wr_en <= 1'b1;
			din   <= din + 1;
		end
	end

	@(posedge sclk)
		wr_en <= 1'b0;


	repeat( 2**`STACK_WIDTH/2 ) begin
		@(posedge sclk) begin
			rd_en <= 1'b1;
		end
	end

	@(posedge sclk)
		rd_en <= 1'b0;

	#50
	repeat( 2**`STACK_WIDTH/2 ) begin
		@(posedge sclk) begin
			rd_en <= 1'b1;
		end
	end

	@(posedge sclk)
		rd_en <= 1'b0;


	#100
	$stop;
end



// 同步堆栈例化
Sync_Stack #(
		.WRITE_GUARD("ON"),
		.DATA_WIDTH (`DATA_WIDTH),
		.STACK_WIDTH(`STACK_WIDTH)
	) U_Sync_Stack (
		.sclk  (sclk),
		.rst_n (rst_n),

		.wr_en (wr_en),
		.din   (din),
		.full  (full),

		.rd_en (rd_en),
		.dout  (dout),
		.empty (empty)
	);


endmodule

开启写满保护模式的栈缓存读写波形如下。测试中栈深度为 16 ，对其写 17 次，可见第 17 个数据 “32’d17” 并没有写入栈中。随后对其读 17 次，可以看到之前写入的数据都按 LIFO 顺序被读了出来。
在这里插入图片描述

关闭写满保护模式的波形如下。测试激励同上，可以看到读取时原来的数据 “32’d16” 的位置被 “32’d17” 覆盖了。
在这里插入图片描述

堆栈verilog设计实现及仿真
QQ_778132974的博客
12-12 821
堆栈顶层模块设计： module stack(input wire clk, reset, push, pop, input wire [15:0] value_in, output wire [15:0] value_out, output wire full, empty); 调用一些下述模块： regr_1 reg1(clk, reset, is_7, is_7_reg); //push mux2 push_checker(push, 1’b0, is_7_reg, write_push); regs
『FPGA通信接口』汇总目录
余生芳华，灵魂共舞
04-13 3824
本文是FPGA通信接口篇的汇总导航，包含内容有整体知识框架，开发环境说明，各专栏导航，文章目录。
数字电路设计之堆栈的verilog实现
I AM BACK
08-05 7239
表面上使用verilog实现POP和PUSH十分简单，实际上这里面还是有点学问的。如果是简单的堆栈实现
Verilog实现堆栈
青春易逝，愿不负昭华，期待梦与远方
12-31 2539
前言 根据网上资料，对栈的基本概念和相关操作进行简要介绍，并作仿真验证。 栈 栈是一种基础的数据结构，只从一端读写数据。基本特点就”后进先出“，例如顺序入栈1,2,3,4,5，再顺序出栈是5,4,3,2,1 栈的基本操作 栈的基本操作有如下几种： 检测栈是否为空 返回栈存储数据的数量 返回栈顶数据/返回栈顶数据并将其弹出 将数据压入栈 清空栈 相关设计和仿真TB如下图 ...
Verilog里实现一个简单的栈
最新发布
2302_80180551的博客
05-08 260
这段代码将index = 0;语句提前到integer i;难道变量声明一定要在begin后面紧接着吗,有大佬解释一下吗。明天再补注释和仿真激励文件了。
堆栈实现
Shroudy的博客
05-21 507
#include “Stack.h” #include <malloc.h> #include <assert.h> #include <stdio.h> void CheckCapacity(Stack* ps) { assert(ps); if (ps->_size == ps->_capacity) { // 开辟新空间 int newCapa...
verilog hdl寄存器堆设计
11-09
verilog hdl 设计寄存器堆，采用译码器、寄存器、数据选择等组合电路
栈与栈的实现
月见樽
11-28 216
栈 栈是一种基础的数据结构，只从一端读写数据。基本特点就”后进先出“，例如顺序入栈1,2,3,4,5，再顺序出栈是5,4,3,2,1 栈的基本操作 栈的基本操作有如下几种： 检测栈是否为空 返回栈存储数据的数量 返回栈顶数据/返回栈顶数据并将其弹出 将数据压入栈 清空栈 栈的实现 软件实现——GO语言 软件的栈可以使用链表基本结构实现或使用数组实现：使...
用Verilog HDL设计深度为128，位宽为8的FIFO
qq_44002905的博客
03-28 415
【代码】用Verilog HDL设计深度为128，位宽为8的FIFO。
【Verilog基础】【计算机体系架构】堆和栈的区别（面试常问）
悟已往之不谏 知来者之可追
09-07 665
【Verilog基础】【计算机体系架构】堆和栈的区别（面试常问）
FPGA实现UDP协议栈，verilog语言附带说明
10-12
FPGA实现UDP协议栈，verilog语言附带说明，测试激励以及测试工具
用堆栈完成对各个进制的转换
05-11
c语言写的用堆栈完成对各个进制的转换，可以随意输入进制并转换成相应的进制
Verilog设计小技巧
Studying……
10-09 1846
这是一个在设计中常犯的错误列表这些错误常使得你的设计不可靠或速度较慢为了提高你的设计性能和提高速度的可靠性你必须确定你的设计通过所有的这些检查 可靠性 **为时钟信号选用全局时钟缓冲器BUFG • 不选用全局时钟缓冲器的时钟将会引入偏差 。 **只用一个时钟沿来寄存数据 • 使用时钟的两个沿是不可靠的因为时钟的某沿或者两个沿会漂移; 如果时钟有漂移而且你只使用了时钟的一个沿你就降低了时钟边沿漂移
关于堆栈的一点认识
yang2011079080010的专栏
05-05 513
特别注意： 堆栈是常用的数据结构，top始终指向的是堆栈中最后入栈数据的下一个地址，也就是说，地址编号为top-1的地址单元存放的是最近入栈的数据，编号为top的单元中没有存数据。 #include #include #include "stack.h" /***** * 关于堆栈的一点认识：设堆栈占用size个地址单元，但堆栈为空时，top=0，有一个元素时，top=1，数据放在编号为
Verilog基础(上)
FPGA自习室的博客
07-06 437
本文主要讲述日常在RTL Coding 时高频出现的几个关键词，熟练掌握不仅可以使得代码简洁，而且效率也可以大大提升。本文介绍的关键词有：parameter、localparam、define、ifdef elseendif generate、for、function和`include。 一、parameter 作用 ： 常用于模块间参数传递，参数化设计。 范围 ： 本module内有效的定义，且定义未声明位宽时系统一般默认32bit。 dram#( .RAM_WIDTH (RAM_WIDTH ),
HDL4SE：软件工程师学习Verilog语言（三）
m0_56903617的博客
05-13 1351
1 引言 2 基本程序结构 3 线缆和寄存器 4 常数、表达式与赋值 5 if语句和case语句 6 always块与initial块 7 task与function 8 元单元 9 编译指示 10 模拟运行与调试
【手撕代码】同步 FIFO、LIFO/Stack
OpenFPGA的博客
06-14 820
FIFO 是FPGA设计中最有用的模块之一。FIFO 在模块之间提供简单的握手和同步机制，是设计人员将数据从一个模块传输到另一个模块的常用选择。在这篇文章中，展示了一个简单的 RTL 同步 FIFO，可以直接在自己的设计中配置和使用它，该设计是完全可综合的。为什么要自己设计FIFO那么，为什么呢？网上有很多关于 FIFO 的 Verilog/VHDL 代码的资源，过去，我自己也使用过其中的一些。但...
Verilog实现同步FIFO(附Verilog代码)
热门推荐
qq_40919669的博客
05-05 1万+
概述 本文为verilog实现同步FIFO的一种方法。fifo作为一种先入先出队列，其本质就是一块存储区域，而先入先出的特性让其读写十分方便，不需要控制地址。而我们在设计的过程中，就是要把读写信号与内存中的地址联系起来。 实现难点 本文利用预先定义二维数组寄存器作为fifo的存储空间。 直白一点讲，一块存储空间存满了就写不进去了，读空了就读不出来了。 verilog实现同步fifo的难点就在于空满标志状态的设计。 读写指针的工作原理 　　读指针：总是指向下一个将要被写入的单元，复位时，...
Verilog学习笔记（5）:Verilog高级程序设计
ixue
10-10 3493
verilog学习笔记；verilog知识总结；verilog考试知识点汇总；Verilog高级程序设计；数字电路系统设计；加法器树乘法；Wallace树乘法器；复数乘法器；FIR滤波器设计；片内存储器的设计；FIFO设计；键盘扫描和编码器；log函数的Verilog设计；CORDIC算法的Verilog实现；总线控制器设计；UART接口控制器；SPI接口控制器
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值