AI芯片设计从入门到进阶：避开放弃陷阱的系统学习路径

这几年，AI芯片设计的热度有多高就不用我多说了。但凡关注点科技领域的动态，几乎天天能看到“大模型算力”“国产替代”“NPU架构”这些词。但热度归热度，真要上手做事情，完全是另一回事。我见过不少朋友，满怀热情买回来几本大部头，装好EDA工具，敲了几行Verilog，然后在一个阳光正好的下午，对着编译报错和一屏乱码，默默地关掉了电脑。这个标题“AI芯片设计从入门到放弃”，可以说是无数后来者的真实写照了。

这篇文章，我想认真聊聊AI芯片设计这个方向。它不是劝退文，也不是速成指南，而是把我自己从“想入门”到“跌跌撞撞做了几个项目”这段路程里，最核心的认知、最常见的坑、以及真正值得投入时间的路线，掰开揉碎讲一遍。不管你是在校学生、软件转硬件的工程师，还是单纯想了解这个行业的人，希望这篇内容能帮你少走一些我走过的弯路。尤其是那些让你“想放弃”的关键节点，其实很多是有办法绕过去的。

1. 热潮背后的冷思考：AI芯片设计到底是个什么事

1.1 一个被误解的“芯片设计”概念

很多人一提“AI芯片设计”，脑子里就是画电路图、调工艺库、做版图、流片，感觉离自己的生活特别远。实际上，AI芯片设计这个行当，远不止是“画电路”这一步。它是一整个软硬结合的工程体系，而且软件部分的比重，常常比大多数人想象的要大得多。

我拿一个比较直观的比喻来说：传统芯片设计像是盖一栋楼，你关心的是结构稳不稳、哪里放承重墙、哪里走管道。而AI芯片设计，更像是设计一座专门为“搬运集装箱”优化的港口，你不仅要把码头（计算单元）建出来，还得设计好集装箱怎么卸、怎么堆、怎么运，甚至得为一种叫“算子”的特殊集装箱定制吊装设备。你面对的不仅是物理层的“怎么实现”，还有逻辑层的“怎么调度才高效”。

具体到技术栈，一个完整的AI芯片设计流程，至少要覆盖这几个层面：

• 算法层面：理解神经网络怎么算，卷积、矩阵乘、激活函数这些核心操作的计算模式；
• 架构层面：决定用哪种数据流，是权重固定还是激活固定，是脉动阵列还是近存计算；
• 逻辑实现层面：用RTL代码（Verilog或SystemVerilog）把架构描述出来；
• 验证层面：确保这个“港口”在各种“风浪”下（各种数据规模、各种精度）都能正确运行；
• 物理设计层面：把逻辑代码变成真正的电路版图；
• 软件工具链层面：写编译器、驱动，让AI框架（PyTorch、TensorFlow）能调用这颗芯片。

这里面的任何一个层面，单拉出来都够一个人钻研好几年。所以说“从入门到放弃”，很多时候不是你不努力，而是你一开始就把“芯片设计”理解窄了，一头扎错了地方，发现怎么都看不到成绩，自然就容易放弃。

1.2 “从入门到放弃”现象背后的三个根因

为什么这个领域“劝退率”这么高？我自己复盘下来，觉得至少有这三个原因：

第一个原因，也是最大的原因——反馈周期太长。你在软件行业写个网页，几秒钟就能看到效果；写个Python脚本，跑一下就知道结果；在AI算法岗调个模型，哪怕训练几天，迭代起来也是以“天”为单位。但在AI芯片设计里，你写了一段RTL代码，想验证它是否正确，光编译仿真环境就要折腾半天，跑一个稍微复杂的测试，仿真时间可能要以“小时”甚至“天”来算。如果你接触到逻辑综合，从代码到网表，又是几个小时起步。这种“写代码一小时，跑仿真一整天，回头发现还得改”的循环，极其磨人。

第二个原因，额外膨胀的知识量。会写Verilog，只是打开了第一扇门。你还需要懂AI算法，才能理解你要加速的东西是什么；需要懂计算机体系结构，才能做出合理的架构决策；需要懂并行计算，才能把数据流安排好；可能还需要懂一些编译原理，才能打通软硬接口。这个知识广度对只有单一背景的人来说是很不友好的，尤其对想跨行的人来说，挫败感非常强烈。

第三个原因，学习资源的“断档”。现在的公开资料里，讲神经网络原理的比比皆是，讲Verilog语法基础的也很多，真正常见的情况是：你刚学完语法，踌躇满志地想做一个AI加速器，结果参考资料要么是学术论文（每一篇都假设你已经懂了全部），要么是工业界的PPT（只讲“我做了什么”，不讲“怎么做”）。中间的“如何从零搭一个能用的系统”这段路，绝大多数人得靠自己去蹚。

1.3 为什么仍然值得去尝试这个方向

前面说了这么多“难”，我并不是要劝退谁。相反，我觉得如果你对“国内被卡脖子的技术之一”这个话题有热情，对软硬结合的挑战有兴趣，AI芯片设计这个方向，仍然是未来五到十年里，人力价值和成长空间都极其可观的方向。

从产业端看，大模型带来的算力需求几乎是永无止境的。GPU虽然通用，但在特定场景下，效率和功耗都不如专用架构。这也就是为什么各大公司都在造自家的AI推理、训练芯片。一个能理解算法、又会做架构设计、还能兼顾工具链的工程师，在任何一家公司都是核心资源。趁早入局，并且坚持下来，这份“冷板凳”坐得长远看是值得的。

从个人成长的角度看，AI芯片设计是一个极好的“通才”训练场。它能逼着你去理解从摩尔定律的底层物理约束、到最上层应用需求的全链路。这种全局视野，是纯软件或者纯硬件岗位都比较难提供的。我在做了几个项目之后，明显感觉到自己看问题的方式变了，会更本能地去思考“这个功能从发出指令到真正完成，中间每一步的开销是多少”。这种思维方式的提升，本身就有很高的价值。

2. 入门前的知识准备：一个系统工程需要具备的知识栈

2.1 硬件基础：数字逻辑与计算机体系结构

想入门AI芯片设计，最底层的数字逻辑基础是绕不开的。这个说起来有点老生常谈，但确实有太多人想跳过。我见过有软件背景的朋友，直接上来就学SystemVerilog和Vivado，结果写出来的代码风格完全是“C语言思维”，到处都是巨大且不切实际的循环，综合出来的电路时序根本收不了。根子就在于对“硬件是并行执行的”这件事没有感知。

数字逻辑里，你真正常用的核心其实是有限的。关键是理解逻辑门、组合逻辑、时序逻辑、时钟和复位这些概念，再搞明白常见的计数器、状态机、FIFO、寄存器和简单ALU的实现。这些东西基本在手写一遍RTL之后就能建立起体感。你也需要克服一个新手最常犯的错误——把硬件代码当成软件顺序执行来写。硬件里，多个逻辑块是在同一个时钟沿同时触发的，数据的时间关系极其严格，这一点只能靠反复实践去内化。

计算机体系结构是另一个重头戏。AI芯片说到底也算是一台“特殊用途的计算机”。理解CPU里面流水线怎么排、缓存怎么工作、存储层次怎么组织、数据一致性怎么保证，这些经典概念虽然看起来跟AI加速器无关，但本质是相通的。比如你在设计一个NPU时，片上SRAM怎么划分、数据怎么搬运、和DDR之间怎么交互，这些其实就是经典体系结构问题在AI场景下的变体。不懂体系结构的人去做AI芯片，大概率会把很多周期浪费在无谓的数据搬运上，设计出来的东西根本跑不出理论算力。

2.2 算法与软件：AI框架与算子背后的原理

很多硬件工程师觉得：“算法那是算法工程师的事，跟我有什么关系？”。这个想法在AI芯片领域真的会吃大亏。你做的硬件最终是要跑“别人”的算法的，如果你完全不理解算法，是没法和算法团队沟通协作的。

但是我也特别想说，你不必非要从头搭一个ResNet，也不用去抠每一个反向传播梯度。你真正需要花时间去搞懂的是“算子的计算模式”。比如卷积，本质就是把一个小的权重矩阵（卷积核）滑过输入特征图，做乘加运算。听起来简单，但它在硬件上怎么高效实现，学问非常大——是每次滑一个像素，还是一次滑几个像素囤积起来并行算？不同stride、dilation怎么处理？通道数不是32的倍数时，MAC阵列怎么对齐？这些才是一个AI芯片设计者需要关心的算法细节。

除了算子本身，你还需要对AI框架（PyTorch、TensorFlow）有一个基本认识。至少要知道：模型是怎么被定义和保存的、在推理时数据是以什么格式（NCHW还是NHWC）传入的、框架在调用GPU时是通过什么接口（比如CUDA）触发的。为什么？因为你设计的芯片要想真正落地，就必须有一套软件栈去承接框架的调用。哪怕你只做硬件，也不能完全不懂这套协议，否则你的硬件接口定义出来，软件团队很可能根本没法对接。

2.3 工具链与语言：从RTL到GDS的漫长入门

聊到工具链，很多新手的第一反应是装Vivado或Quartus，然后建一个工程、点亮几个LED，就觉得自己入门了。说实话，这距离真正的“AI芯片设计”还差得很远。

工具链其实分好几个层次。最基础的是RTL仿真工具，比如商业的VCS、ModelSim，或者开源的Icarus Verilog、Verilator。仿真验证是日常开发里的绝对核心工作。再往后是逻辑综合工具（Synopsys Design Compiler、Cadence Genus），它把RTL代码转成门级网表，同时会做时序约束和功耗评估。再远一步是版图设计工具，也就是把门级网表变成物理布局布线，这一步通常涉及大量工艺库和物理规则，也是传统芯片设计进入“高端局”的地方。

对于入门的人，我的建议是：先不要碰复杂的物理设计和后端，那些等到你真正决定深耕再看也不迟。你先要把“仿真”这件事玩得滚瓜烂熟，因为仿真速度和调试方法的熟练度，直接决定了你的开发效率。我个人用下来，Verilator + SystemVerilog + 一段Python辅助脚本这套组合，非常适合入门阶段学习用——开源免费，跑得快，还有足够多的调试手段。等你真的开始做Zynq平台上的FPGA原型验证时，再去深入Vivado也不迟。

3. 从零开始的真实学习路径：我建议的分阶段路线

3.1 第一阶段：学会“造零件”，而不是“抄代码”

很多人入门硬件的第一课是抄别人的代码，然后跑通仿真。我觉得这只能算“热身”，不能算“入门”。真正的入门，得从“我自己能设计一个简单的部件”开始。

我给你的建议是，花两周时间，用SystemVerilog把以下这些部件各写一遍，并且不能用网上现成IP，全部手敲：

• 同步FIFO和异步FIFO（体会读写指针、格雷码跨时钟域）；
• 带使能信号的并行乘法器（体会流水线插入和组合逻辑时序收敛）；
• 无阻塞赋值的移位寄存器（体会阻塞赋值和非阻塞赋值的区别）；
• 一个简单的状态机，比如UART接收器（体会状态转移和时序配合）；
• 一个参数化的MAC（乘累加）单元，支持不同位宽（这是后面做AI加速器最重要的零件之一）。

这个阶段最容易踩的坑是：对着波形图看半天，不知道自己写的代码哪里错了。实际上，硬件调试的核心套路是“波形不对，先去检查时序逻辑的触发条件；时序逻辑没问题，再去查组合逻辑的竞争冒险”。你要学会用波形对比预期。

我建议你用Verilator + Verilog自带的任务（$display, $monitor）或者去查看波形文件（VCD/FST），养成先把预期结果写成testbench注释的习惯。别小看这个习惯，它能逼着你建立“硬件设计需要以验证为导向”的思维，这在后续复杂的系统里极其重要。

3.2 第二阶段：围绕AI算子做硬件建模

零件造得差不多了，就可以开始引入AI的背景了。这一阶段不要一上来就做一个完整的NPU，那太快了，适合作死。更好的切入点是先做一个专门的算子加速单元。

我建议先做矩阵乘法或卷积加速。你可能在脑子里也想不清楚卷积矩阵到底怎么铺数据，没关系，画图找感觉。我通常建议在你动手写RTL之前，先用Python写一个高层的参考模型，把卷积的计算过程用最简单的三重循环实现一遍。这个参考模型有几个作用：一是帮你在RTL设计之前理清数据流；二是作为后面对比仿真结果的“金标准”；三是你可以基于这个模型，去验证你设计的数据分块方案是否属实。

RTL设计层面，从零搭一个简单的卷积加速器，需要考虑的核心问题我认为是这些：

• 数据输入：输入特征图数据怎么从外部存储（比如DDR模型）搬到片上BRAM？需要按什么顺序去读？
• 权重缓存：卷积核权重是预加载的还是动态加载的？如果模型不止一个卷积层，权重如何换入换出？
• 计算阵列：你是做一个MAC然后循环很多次，还是做2x2、4x4的MAC阵列并行计算？并行度越高，数据供给压力越大。
• 累加器：偏置怎么加？激活函数（ReLU、Sigmoid）是放在加速器里做，还是留给外部CPU做？
• 输出回写：算完的结果按什么格式写回？需不需要做池化？

这个阶段的工作量通常需要4到6周，取决于你的业余时间。但一旦你把一个像样的卷积加速单元调通，并且能和Python参考模型对比结果一致，你会获得极大的正反馈。这算是你“赚到”的第一个里程碑。很多人在这个阶段放弃，往往是因为没有参考模型，自己跟自己较劲，仿半天也不知道结果对不对。所以务必先写Python参考模型，这是我从无数次踩坑里总结出来的。

3.3 第三阶段：打通软硬件接口，理解生态

硬件模块能跑了，下一步要做的不是马上流片，而是想办法让它被“软件”用起来。这一步是区分“会写RTL”和“能做AI芯片”的分水岭。

在这个阶段，你可以选择两种路线。一个是学习RISC-V，自己在上面扩展一条自定义指令来配置加速器寄存器；另一个是用一个简单的CPU软核（比如开源的VexRiscv或PULPissimo），把加速器挂到总线上，然后在CPU上写C程序来控制数据的搬运和计算任务的启动。

我个人更推荐第二条路线。因为它更贴近工业界的真实形态。AI芯片不是一个孤岛，它外面都要有个控制核（通常是ARM或RISC-V）来调度。你把加速器做成一个内存映射的外设，CPU通过写寄存器来配置地址、启动信号、轮询状态，这一套“寄存器级编程”的流程走通了，你才算真正体会到AI芯片里“软硬件协同”是怎么运作的。

我特别要说一下，这个阶段你会第一次深刻体会到“系统总线的性能瓶颈”。你会发现，明明你自己的加速器算得很快，但从DDR读数据的时候，总线一拍只能传128bit，完全喂不饱加速器。这时候你才真正理解为什么工业级芯片需要把计算阵列和存储层次紧密耦合，为什么要做片上多级缓存。

3.4 第四阶段：找一个具体场景做垂直项目

等你把系统打通了，接下来的学习就不应该再是“跟着教程走”，而是给自己找一个真实场景，做垂直项目。场景不用大，但要有具体的目标和约束条件。

比如可以给自己定一个小目标：做一个“YOLOv5目标检测加速器”的FPGA原型，要求在100MHz下达到50FPS的处理速度，同时功耗不能超过多少。听起来很简单，但真正做起来，你会发现要去解决一堆问题：模型怎么量化（INT8还是INT16）？不同层的计算量差别巨大，用同一个加速器跑全部层是否划算？需要不用分批调度？数据在片上缓存和外部存储之间的搬运怎么安排？如果你只做一个卷积单元，那FC层、池化层、上采样怎么办？

这种垂直项目会让你暴露在工程决策的真实复杂性里。你会不得不去查论文、翻开源IP文档、跟朋友讨论，然后你会发现你不仅是在“画电路”，而是在做“架构权衡”。这是和高性能计算、算法优化最相通的地方，也是AI芯片设计最有意思的部分。到了这个阶段，你就已经从“入门”迈向了“历练”，不再是被动地接收知识，而是主动地搜索解决问题的方法。放弃的概率就低很多了。

4. 实操过程：用SystemVerilog写一个简单的卷积加速单元

这一章我来带你走一遍“算子加速器”的最小实现。不是完整的工业级代码，但足以说明核心思路，同时把我在这个过程中反复踩的坑指出来。这个小项目也是我当年第一个真正跑通的AI硬件模块，至今依然是我讲课时会用的例子。

4.1 任务定义：把卷积计算映射到硬件

我们先定一个很小的目标：实现一个3x3卷积核、处理单通道8x8输入特征图的加速单元。输出尺寸为6x6（没有padding，stride=1）。

步骤上，先写Python参考模型：

import numpy as np def conv2d_simple(input_feat, kernel): # input_feat: (8,8), kernel: (3,3) out_h, out_w = 6, 6 output = np.zeros((out_h, out_w)) for i in range(out_h): for j in range(out_w): acc = 0 for kh in range(3): for kw in range(3): acc += input_feat[i+kh][j+kw] * kernel[kh][kw] output[i][j] = acc return output

前三层循环长得很“软件”，但它恰恰是后面硬件设计的模板。硬件设计的核心就是：把这四层循环里的数据流和计算爆炸成硬件里并行的乘法器和累加器。

然后，我设计一个最简单的硬件架构：

• 输入特征图（8x8）和卷积核（3x3）存在片上SRAM（在仿真里直接用寄存器数组）。
• 设计一个MAC单元：每个周期取一个输入像素和对应权重，做一次乘法，并累加。
• 采用滑窗的方式，逐步产生每一行每一列的卷积结果。
• 一个小的状态机控制：加载权重 -> 计算 -> 输出结果。

4.2 RTL代码片段与关键结构说明

我挑两个关键片段写一下，完整的testbench留给你自己补全。

权重与输入存储可以这样定义：

logic [7:0] input_feat [0:7][0:7]; logic [7:0] weight [0:2][0:2]; logic [15:0] acc;

这里的数字是无符号定点数，为了简化先不引入浮点。如果要接更高精度的模型，量化的处理是另一门学问，后面再说。

MAC状态机的核心部分可以写成这样：

typedef enum {IDLE, LOAD_WEIGHT, COMPUTE, WRITE_OUT, DONE} state_t; state_t state; // 卷积窗口位置 int i, j, kh, kw; always_ff @(posedge clk or negedge rst_n) begin if (!rst_n) begin state <= IDLE; acc <= 0; out_valid <= 0; end else begin case (state) IDLE: begin i <= 0; j <= 0; kh <= 0; kw <= 0; acc <= 0; state <= LOAD_WEIGHT; end LOAD_WEIGHT: begin // 理论上权重从外部加载，这里用组合逻辑直接读 state <= COMPUTE; end COMPUTE: begin // 一个周期完成一次乘加 acc <= acc + input_feat[i+kh][j+kw] * weight[kh][kw]; if (kw < 2) begin kw <= kw + 1; end else if (kh < 2) begin kh <= kh + 1; kw <= 0; end else begin // 完成一个输出点的所有乘加 state <= WRITE_OUT; end end WRITE_OUT: begin // 把 acc 写入输出特征图的对应位置 out_feat[i][j] <= acc; acc <= 0; kh <= 0; kw <= 0; if (j < 5) begin j <= j + 1; state <= COMPUTE; end else if (i < 5) begin i <= i + 1; j <= 0; state <= COMPUTE; end else begin state <= DONE; end end DONE: begin out_valid <= 1; end endcase end end

这里有两个新手非常容易踩的坑。第一，我在WRITE_OUT里把输出地址直接写成了 out_feat[i][j]，但在同一个周期里，i和j还是旧值吗？这其实涉及non-blocking赋值的时间语义问题。在always_ff块里，所有右侧表达式读取的是当前时钟沿之前的值，而左边更新要到这个时钟沿之后才生效。所以你可能会发现生成的地址不对，或者计算窗口根本没移动。我的习惯是，在状态机的每个周期里，凡是要用当前窗口位置做事情，就把位置变量更新和运算拆开，或者用临时变量备份，避免踩进non-blocking的时间差陷阱。

第二个坑是，我上面的代码里把输出结果累加的节奏和窗口跳转严格绑在一起了。但实际上，硬件里你可能得用两套索引：一套是计算窗口位置，另一套是读取输入数据的地址。如果直接把计算和地址生成混在一个状态里，后期当你加流水、多路并行时，完全没法扩展。建议你从一开始就做好地址生成器的独立模块设计，哪怕只是个小的function。

4.3 仿真验证与Python参考模型对比

状态机写完之后，最重要的步骤就是做仿真验证。我在仿真里生成了随机输入，再把RTL仿真输出导到文件，然后和Python算出来的结果逐项对比。

操作方法是这样的：在testbench里，给足够的时钟周期让状态机跑完，然后以文本形式把输出特征图打印出来。用Python读取这个输出，和前面参考模型的矩阵做np.allclose(..., atol=1e-3)，比对时去掉定点截断误差，或者直接在RTL里就用整数运算，完全严格比对。

这一步在对上的一瞬间，你真的会从椅子上跳起来。我当时从写Python参考模型到RTL调通，差不多花了两个周末。最大的收获不是代码本身，而是彻底搞明白了“算法循环映射成硬件状态机”的思路。

我也要提醒你，这个最小模型还有很多细节没有处理。比如没有做池化、没有ReLU、不支持多通道。如果你要把它扩展成一个可用的模块，建议按这个节奏来：先把单通道版本跑到结果一致，再加多通道累加，然后加ReLU和pooling，最后再聊数据搬移和量化。一步一个脚印，每个阶段都有可验证的中间结果，你才有底气继续往下走。

5. 常见问题与排查技巧实录

5.1 下面几张“放弃高危节点”的避坑清单

我根据自己和身边人走过的坑，整理了一张“放弃高危节点”清单。如果你在某个阶段卡住了，对照一下，大概率能找到原因。

5.2 工具选型与开源项目的取舍经验

工具链这块，我给新手的建议是：尽量选业界主流，但不必一上来就追求“全家桶”。商业EDA工具（VCS、Design Compiler等）功能强大，但价格和授权对个人来说基本不可能拿到。如果你是学生，可以看学校有没有正版授权；如果纯粹自学，我建议优先吃透开源路线：Verilator做仿真，GTKWave看波形，用CMake或Makefile管理多文件工程，用Python脚本做数据分析。这一套组合学熟了，将来接触商业工具也能很快上手，因为仿真的思想是共通的。

开源IP方面，我特别推荐去看一些知名的高质量项目，但我不建议你直接去“抄”他们的顶层架构，而是去“读”并“拆解”他们的微架构。比如：

• 去看一个开源TPU/NPU项目里，它的ping-pong buffer是怎么设计的；
• 去看RISC-V SoC里，AXI总线协议和加速器之间是怎么握手的；
• 去看OpenPOWER、Chipyard这类项目的生成工具链，理解Meta-programming在硬件生成里怎么用。

这种“阅读源码+心智建模”的学习方式，比照着教程搭积木有用得多。你可能读不懂每一个细节，但那种“原来这里还能这么设计”的瞬间，正是最宝贵的收获。

5.3 关于验证、调试态度和坚持的一点实话

最后，我得跟你说点大实话。这行的常态是“90%的时间在调试和验证，10%的时间在写新代码”，而不是反过来。很多新手一上来就想快速堆功能，结果代码写得飞快，最后找bug的时间是自己的三倍起步。我做小项目的时候，有一半时间都在写testbench和参考模型，真正的功能代码反而不多。因为CPU和DDR、DMA、中断、总线优先级这些是紧密结合的，任何一环出了问题，整个系统都会莫名其妙“死掉”。

遇到这种情况，我给自己定的原则是：先允许自己“出错”，然后再系统性地排查。不要用“瞎试法”去盲目改代码，那样只会越改越乱，最后连自己都搞不清楚什么是对的了。硬件的调试方法比软件更讲究“可观测性”——所以我会经常打印关键信号，甚至在RTL里预留一些调试寄存器，便于查看内部状态。一旦你想通了某个“疑难杂症”，那种成就感和快乐，也是别的行业很难给的。

6. 写在最后：关于“放弃”的一些个人理解

聊了这么多，你会发现，AI芯片设计的门槛确实不低，但它之所以容易让人“放弃”，很多时候不是因为它有多难，而是因为它太考验耐心，又太容易让人在早期看不到正向反馈。

我个人的体会是：要把这个方向当成“长跑”，而不是“百米冲刺”。你在最初几个月里，很可能做出的东西就是一个能跑卷积的小模块，跟“芯片”两个字完全不沾边。但这颗小种子，只要你给它足够的营养和时间，它会慢慢长成参天大树。很多大佬回忆起自己入行时做过的第一个“玩具”，往往也特别简陋，这并不丢人。

如果让我再给一个最真诚的建议，我会说：尽早找一个人跟你一起学。硬件学习最劝退的时刻，通常是一个人对着屏幕发呆的深夜。有个同伴互相讲代码、互相你写的上层通路怎么调、一起对着波形图找bug，能让你在“想放弃”的边缘多撑好几个来回。等你好不容易把一个模块调通了，把一段波形看明白了，你会发现自己已经悄然走在“不放弃”的路上了。

最后再分享一个小技巧吧。如果你真的决定入坑，可以给自己定一个“最小正反馈”项目：不要管什么高深理论，先花一个周末，把一个4x4矩阵乘法用SystemVerilog写出来、仿真通过，再用Python验证结果一致。就这么一点点小成功，足够支撑你走过最开始的迷茫期了。后面的路还长，但风景真的值得。