Desim

Desim 是一个用 Python 实现的离散事件仿真框架，专门用于电路仿真，功能类似于 SystemC。它提供了基于协程的并发仿真机制，支持事件驱动的仿真调度。

特性

• 离散事件仿真: 基于事件的调度机制，支持精确的时间控制
• 协程并发: 使用 greenlet 实现轻量级协程，支持并发仿真
• 内存仿真: 支持依赖关系内存和块内存仿真
• 同步原语: 提供信号量、事件队列等同步机制
• 通信机制: 支持 FIFO 等通信组件
• 类型安全: 使用 Python 类型注解，提供良好的类型安全

安装

pip install -e .

或者从源码安装：

git clone https://github.com/Xyfuture/Desim.git
cd Desim
pip install -e .

快速开始

基础仿真示例

from Desim.Core import SimSession, SimModule, Event, SimTime

class MyModule(SimModule):
    def __init__(self):
        super().__init__()
        self.event1 = Event()
        self.event2 = Event()
        
        # 注册协程
        self.register_coroutine(self.producer)
        self.register_coroutine(self.consumer)
    
    def producer(self):
        for i in range(5):
            print(f"[Producer] Producing at time {SimSession.sim_time}")
            self.event1.notify(SimTime(1))  # 1个周期后通知
            SimModule.wait(self.event2)     # 等待事件2
    
    def consumer(self):
        for i in range(5):
            SimModule.wait(self.event1)     # 等待事件1
            print(f"[Consumer] Consuming at time {SimSession.sim_time}")
            self.event2.notify(SimTime(1))  # 1个周期后通知

# 初始化仿真
SimSession.reset()
SimSession.init()

# 创建并运行模块
module = MyModule()
SimSession.scheduler.run()

FIFO 通信示例

from Desim.module.FIFO import FIFO

class FifoTest(SimModule):
    def __init__(self):
        super().__init__()
        self.fifo = FIFO(3)  # 创建大小为3的FIFO
        self.register_coroutine(self.producer)
        self.register_coroutine(self.consumer)
    
    def producer(self):
        for i in range(5):
            self.fifo.write(i)
            print(f"Producer Write {i} at {SimSession.sim_time}")
            SimModule.wait_time(SimTime(2))  # 等待2个周期
    
    def consumer(self):
        for i in range(5):
            data = self.fifo.read()
            print(f"Consumer Read {data} at {SimSession.sim_time}")
            SimModule.wait_time(SimTime(10))  # 等待10个周期

SimSession.reset()
SimSession.init()
module = FifoTest()
SimSession.scheduler.run()

核心组件

SimTime

时间管理类，支持周期和 delta 周期：

t = SimTime(cycle=10, delta_cycle=1)  # 10.1个周期
t2 = SimTime(5)  # 5个周期

Event

事件机制，用于协程间的同步：

event = Event()
event.notify(SimTime(5))  # 5个周期后触发
SimModule.wait(event)     # 等待事件触发

SimModule

仿真模块基类，所有仿真组件都继承自此：

class MyModule(SimModule):
    def __init__(self):
        super().__init__()
        self.register_coroutine(self.my_process)
    
    def my_process(self):
        # 仿真逻辑
        pass

SimSemaphore

信号量同步原语：

semaphore = SimSemaphore(3)  # 初始值为3的信号量
semaphore.wait()            # 等待资源
semaphore.post()            # 释放资源

# 支持上下文管理器
with semaphore:
    # 临界区代码
    pass

内存仿真

DepMemory

依赖关系内存，维护读写依赖关系：

from Desim.memory.Memory import DepMemory, DepMemoryPort

memory = DepMemory()
port = DepMemoryPort()
port.config_dep_memory(memory)

# 读写操作
data = port.read(addr=0x1000, tag_value=1)
port.write(addr=0x1000, data=42)

ChunkMemory

块内存仿真，支持可配置的带宽和块大小：

from Desim.memory.Memory import ChunkMemory, ChunkMemoryPort

memory = ChunkMemory(bandwidth=64)  # 64字节/周期
port = ChunkMemoryPort()
port.config_chunk_memory(memory)

# 读写操作，支持块传输
data = port.read(addr=0x1000, num_elements=128, 
                batch_size=16, element_bytes=4)
port.write(addr=0x1000, data=data, 
          num_elements=128, batch_size=16, element_bytes=4)

开发

安装开发依赖

pip install -e ".[dev]"

运行测试

pytest

代码格式化

black src/
isort src/

类型检查

mypy src/

项目结构

Desim/
├── src/Desim/
│   ├── Core.py          # 核心仿真引擎
│   ├── Sync.py          # 同步原语
│   ├── Utils.py         # 工具类
│   ├── module/          # 仿真模块
│   │   ├── FIFO.py      # FIFO实现
│   │   └── Pipeline.py  # 流水线实现
│   └── memory/          # 内存仿真
│       └── Memory.py    # 内存模块
├── examples/            # 示例代码
└── tests/              # 测试代码

许可证

MIT License

贡献

欢迎提交 Issue 和 Pull Request！

相关链接

• GitHub Repository
• Issues