上世纪80年代早期，高性能计算机的设计很大程度上是数据驱动的。例如对指令使用情况的分析发现在真实的机器上，不是每种指令都是以相同的频率被执行。设计人员利用这一观察来优化这些机器的具体实现。但是，这种直接的测量属于后设计操作步骤，并不总能在设计阶段帮助优化。作为替代方案，架构师们使用分析模型来预测性能，它们在初始阶段剔除一部分设计空间是成功的，但是在评估更复杂的设计权衡时不是那么奏效。

随着工艺节点的进步，片上能塞进更多的晶体管，计算机系统可以变得十分复杂。早在2004年，由于风冷芯片最大功耗和无法有效地开发更多指令集并行这两大孪生瓶颈，Intel取消自己的高性能单核处理器项目转向多核心开发。面对多核心，更深的存储层次，异构计算等日益复杂的计算系统，设计师们开始诉诸仿真模型在项目初期预测机器性能。

这些仿真模型大多使用高层次编程语言来编写，例如C或者C++。它们不仅要保证很高的评估保真度，而且在仿真速度上要比RTL高几个数量级。常见的性能仿真器有：Rsim, Simics, SimpleScalar和 Asim

2 gem5简介²

2.1 gem5是什么

The gem5 simulator is a modular platform for computer-system architecture research, encompassing system-level architecture as well as processor microarchitecture³

• gem5是一个开源的计算机系统性能仿真器，既可以全系统仿真也可以进行处理器的微架构仿真。
• gem5融合了M5和GEMS仿真器两者最好的部分。M5提供高度可配置的仿真框架，多个ISAs还有多种CPU模型。GEMS通过详细且扩展性好的内存系统补充M5这些特点。
• gem5是一个精英管理的社区工具。其良好的可扩展性，模块化仿真对象和简洁明确的接口使得研究者们可以专注于特定部分代码而无需理解全部代码。

2.2 为什么使用gem5⁴

• 运行真实的负载(比如运行像Linux，Android等复杂的负载)
• 提供系统级别的视野(比如设备之间的交互，操作系统交互)
• 挂载定制的模型(gem5提供了封装有通用外设接口的基类，开箱即用的常见硬件模型)
• 早期快速原型验证(通过参数化的模型使能快速设计空间探索)
• gem5在工业和学术界有大量的用户群体(自从2011年合并以来，gem5 已被 2900 多篇出版物引用)

2.3 gem5设计特色

设计gem5时使用了很多卓越软件工程实践的方法：无处不在的面向对象, 集成Python, 领域特定语言(DSL)和标准的接口

• 可扩展性是gem5模拟器一个重要的目标，也是它成功的关键因素。而这种特性很大一部分是通过底层C++代码面向对象设计实现的。也正是由于gem5扩展性好，可以满足不同仿真任务的需求。例如，当一个想法从高层次的概念到具体的设计实现孵化过程中，架构师需要一个能在不同抽象层级上仿真的工具，兼具仿真速度和正确性。一个细粒度的门控实验可能需要详细的CPU模型，而对多核的建模不是必须的；与此同时一个高度可伸缩互连模型可能需要多个CPU,但是这些CPU没必要建模太多细节。此外，随着时间的推移，通过长期使用一个仿真配套设施，架构师能够以更少的开销更快地完成更多的工作。

• Python集成使得gem5的配置变得更加灵活，同时对用户的接口也更加友好。python主要完成仿真对象配置，初始化，构建系统的拓扑结构和仿真流的控制。

• DSL的使用使得gem5在ISA和Cache Coherence建模上更加简洁和高效。

• gem5定义了一个重要的port interface，Ports用来连接gem5中两个内存对象。内存对象通过一个叫Packet的内存请求对象来传递消息。

2.4 gem5常见的模型

1. CPU 模型

   

   • 从左到右建模得越来越详细，实现的功能也更多，但是仿真速度越来越慢。

2. 系统模式

1. 内存 模型

   

   • gem5提供两种内存模型：Classic 和 Ruby
   • 在上图的例子中不需要使用Ruby选项运行gem5。但是如果研究缓存一致性协议，则可能需要使用Ruby模型，因为它提供了扩展性好的内存系统(SLICC用于缓存协议的领域专用语言），详细的统计数据和部件仿真模型。

3 gem5开发介绍

几乎所有的gem5仿真对象使用C++编写，外面用Python包裹。gem5使用pybind11工具完成C++对象和Python对象之间的绑定，而整个项目的编译则由Scons构建工具完成。

3.1 gem5编译

• 下载gem5源代码(写此文时最新稳定版本为v21.0.1.0)

  git clone https://gem5.googlesource.com/public/gem5

• 编译gem5

  • 首先根据官方介绍下载依赖(主要有python3和scons)

  • 进行编译(可以选择gem5/build_opts下任意一个ISA和缓存一致性协议进行编译)

    1	python3 `which scons` build/ARM/gem5.opt -j $(nproc)

  • 上面使用的ARM ISA进行编译，并编译了所有的CPU model，也可以修改gem5/build_opts/ARM，只编译一部分CPU模型。

  • gem5有五种二进制类型: debug, opt, fast, prof 和perf。具体差别见官网介绍。通常使用opt类型。

3.2 创建gem5仿真对象

gem5 中的所有主要仿真组件都是继承SimObjects， 并都具有配置、初始化、统计和序列化(检查点)的常见行为。每个仿真对象由两个类代表，一个在C++中，一个在Python中。

所有的仿真对象需要放在gem5/src目录下面，每次修改后需要重新编译，才能在仿真脚本中引用得到。

1. Python file
   

   • 创建一个与C++对象同名的类，并继承SimObject
   • 指明C++头文件位置(相对gem5/src目录的位置)
   • 声明该对象可配置的参数，并可以赋予初值。(第一次参数为初值，第二参数为说明)

2. C++文件(一个头文件声明，一个文件进行函数实现)

   

   

   • C++对象继承SimObject,同时使用member initializer lists(成员初始化列表)给类成员在构造函数中赋初值
   • gem5有一种机制，根据python对象名自动创建一个xxxParams类，并且该类包含了python文件中给的初始值。

3. SConscript文件(类似cmake中的CMakeLists.txt)

   

   • SConscript相当于python脚本，可以写任何符合python语法的程序。
   • Import，DebugFlag，SimObject, Source都是Scons提供的方法，便于用户使用。

3.3 仿真配置脚本

gem5 源代码提供了很多实用程序和通用的配置脚本文件，都放在gem5/config/目录下。

• 首先引入仿真对象

  1 2	import m5 from m5.objects import *

• 创建一个root对象，系统中所有对象都是它的子对象(注：通常所有对象挂载在root.system层次下面，本次实验为了简单，没有使用system对象)

  1	root = Root(full_system = False)

• 实例化一个HelloObject对象，并挂载在root下面（gem5中内存对象至少有一个slave或master端口，当python中用=操作符进行连接时，底层调用端口连接函数）

  1 2	root.hello_test = HelloObject(time_to_wait='2ns', number_of_fires=10) # 可以通过配置脚本覆盖参数的默认值

• 系统搭建完毕后就可以仿真

  1 2 3 4

  m5.instantiate() print("Beginning simulation!") exit_event = m5.simulate() print('Exiting @ tick %i because %s' % (m5.curTick(), exit_event.getCause()))

  3.4 开始仿真

仿真命令类似如下：

build/ARM/gem5.opt --debug-flags=HelloExample configs/learning_gem5/part2/hello_goodbye.py

---

完整的实验步骤请参考官网教程

4 DVFS背景

DVFS全称为动态电压频率缩放，是一种重要的电源管理方法。本部分内容主要来自2013年的一篇论文³

想要在gem5中模型DVFS需要做哪些东西呢？

• 硬件支持
  • CPU等硬件支持多频率电压工作
  • 需要设计一个DVFS controller与软件交互
• 软件支持
  • 通常Linux上已经存在DVFS governor可以复用(高层次模块)
  • 我们只需要设计底层驱动，特定于硬件
• 功耗评估模型
  • 实时统计系统功耗，输入给温控系统
  • 比较DVFS策略的能耗效率

4.1 DVFS controller

• 外部提供三个寄存器：domain_id(每个时钟域下可以有多个仿真对象),Freq level(从012开始编号,编号越小频率越高),Ack(只读寄存器，读完清零，当当前转换完成时硬件置1)
• 内部记录各个时钟域的相关信息，并响应请求进行时钟电压的变换。
• 还需要抽象一个DVFS Handler仿真对象(不是IO设备),方便用户将时钟域配置进去。

4.2 Linux cpufreq driver

• Linux内核一般有DVFS管理驱动程序。performance: 始终以最大频率运行;powersave: 始终以最低频率运行;userspace:用户自行调整频率，通过向scaling_stepeed文件写入频率值。ondemand:系统根据负载需要自行调整频率。
• 下层驱动需要与dvfs controller交互，同时给上层管理程序提供服务。这部分特定于硬件实现，但是只要符合上层驱动的接口规范，就可以不用修改地复用上层模块。
• 当需要模拟不同的电压-频率点时，只需要修改设备树文件，底层驱动从设备树文件初始化硬件，而不需重新编译下层驱动。

4.3 power model

gem5是个模块化的系统，通过累加每个模块的能耗得出整体的能耗。每个模块分为5种电源状态，每个状态又分别由动态功耗和静态功耗组成。模块处于何种状态由系统决定，模块每种状态下计算功耗的公式人为给定。

5 DVFS实验

本次实验主要参考官方教程中的ARM power Modelling和ARM DVFS Support

• 目前最新版本(v21.0.1.0)的gem5已经内置了DVFS controller，并且提供了DVFS_Handler仿真对象

  

  

  • 在系统仿真配置文件中使能DVFS_Handler，并将需要模拟的时钟域注册进去。

  • 当前系统参数文件见：gem5/m5out/config.ini 或者config.json文件

• gem5官方提供的修改过后的Linux版本内置了DVFS底层驱动

  • 当gem5以全系统模式仿真时，通过设置不同DVFS governor，即不同的策略，来实现动态的电压频率缩放。
  • 本次实验使用的v4.4内核，底层驱动为arm-gem5-mc

  

5.1 功耗估计模型

下面代码见gem5/configs/example/arm/fs_power.py文件

gem5提供的MathExprPowerModel类，用于用公式表达一种电源状态下模块的动静态功耗。gem5提供的PowerModel类用于封装模块4种状态下的功耗模型。

每个模块一般都会有各种统计信息可以用于功耗公式中，例如CPU模块的统计参数见:gem5/src/cpu/base.cc中的 ADD_STAT(numCycles, UNIT_CYCLE, "Number of cpu cycles simulated")等。Cache模块的统计参数见:gem5/src/mem/cache/base.cc中的ADD_STAT(overallMisses, UNIT_COUNT, "number of overall misses")等。

如果遇到fatal: Failed to evaluate power expressions: [...]，多半是因为当前模块没有该统计参数或者名称输入错误。解决办法：用vscode打开gem5/src文件夹，然后搜索ADD_STAT(xxx)，查看当前参数在哪个类中定义；或者查找相近的统计参数名称进行比对。

将之前定义的CPUPowerModel类注册到系统中所有CPU中，这样全系统仿真时才会有CPU的功耗统计结果。

最后，可以设置每间隔多长时间，dump一次统计数据(👇使用间隔为0.01s仿真时间，默认为1s)

1	m5.stats.periodicStatDump(m5.ticks.fromSeconds(0.1E-1))

5.2 设置时钟-电压域

• 电压域包含在时钟域里面
• 电压域如果是单值——时钟域可以是单值也可以是多值
• 电压域如果是多值——时钟域必须是多值，且项数与电压域匹配(使用降序)

1. 首先在gem5/configs/example/arm/devices.py中的CpuCluster类中self.clk_domain中，加入domain_id=system.numCpuClusters()，因为domain_id必须唯一。(当系统实例化bigCluster时domai_id=0，接着实例化littleCluster时domain_id=1)

1. 接在在gem5/configs/example/arm/fs_bigLITTLE.py，加入对大小核时钟和电压的命令行参数输入。

   

2. 将电压和频率配置进CpuCluster中

   

5.3 全系统仿真

1
2
3
4
5
6
7
8
9
10
11
12

> cd your/gem5/main/directory
> build/ARM/gem5.opt \
--debug-flags=dvfs_handler,EnergyCtrl \
--debug-file=dvfs_debug.log  \
configs/example/arm/fs_power.py  \
--kernel=../full_system_for_gem5/binaries/vmlinux_4.4 \
--cache  \
--dvfs \
--big-cpu-clock 3GHz 2GHz 1GHz 900MHz \
--big-cpu-voltage 1.0V 0.9V 0.8V 0.5V \
--little-cpu-clock 2GHz 1GHz 800MHz 500MHz \
--little-cpu-voltage 1.0V 0.8V 0.6V 0.5Vs

• 设置debug-flags为dvfs_handler和EnergyCtrl
• 设置debug-file为dvfs_debug.log，此文件将记录系统初始化DVFS，频率切换过程等
• —kernel指定内核，本次实验使用的是v4.4。
• 可以使用—disk设置镜像文件位置，脚本默认镜像为aarch64-ubuntu-trusty-headless.img，可以通过网址下载。
• 需要设置M5_PATH环境变量，该目录包含两个文件夹，分别为binary和disk，把编译好的内核vmlinux复制到binary文件夹下，下载好的镜像复制到disk文件夹下。

1. 另开一个终端，输入命令telnet localhost 3456，等待两到三小时后(因为默认大核使用的O3 CPU，小核使用的Minor CPU，所以启动Linux很慢)，进入Linux命令行，输入root即可。

   

2. 进入cpufreq目录(dvfs内核接口)

   1 2	> cd /sys/devices/system/cpu/cpu0/cpufreq > ls

   该目录下有很多与dvfs有关的信息文件，比如scaling_driver即底层驱动名称，scaling_governor为高层驱动名称。cpuinfo_tarnsition_latency为频率调整时间，cpuinfo_cur_freq为当前CPU频率等。

   

   1	> cat scaling_available_frequencies

   

   1 2 3 4

   > echo "userspace" > scaling_governor > cat cpuinfo_cur_freq > echo "3003003" > scaling_setspeed > cat cpuinfo_cur_freq

   

5.4 Benchmark比较

通过跑stamp-roi-o2/genome/genome_roi_lock来比较performance和Ondemand不同调度策略的效率。

1. 在5.3节中我们已经进入仿真系统的Linux命令行，由于Linux默认调度程序为perfermance，所以先保存一个检查点。

   1	> m5 checkpoint

   保存的检查点文件夹在gem5/m5out下，一般以cpt.xxx命名的目录下(xxx为从仿真开始到执行checkpoint这段时间的时钟tick数)

2. 然后，调整scaling_governor为ondemand后，再保存一个检查点。

   1 2	> echo "ondemand" > /sys/devices/system/cpu/cpu0/cpufreq/scaling_governor > m5 checkpoint

3. 从perfermance恢复，然后开始执行程序

   1 2 3 4 5 6 7 8 9 10 11 12 13 14

   > build/ARM/gem5.opt \ --debug-flags=dvfs_handler,EnergyCtrl \ --debug-file=dvfs_debug.log \ configs/example/arm/fs_power.py \ --kernel=../full_system_for_gem5/binaries/vmlinux_4.4 \ --cache \ --dvfs \ --big-cpu-clock 3GHz 2GHz 1GHz 900MHz \ --big-cpu-voltage 1.0V 0.9V 0.8V 0.5V \ --little-cpu-clock 2GHz 1GHz 800MHz 500MHz \ --little-cpu-voltage 1.0V 0.8V 0.6V 0.5Vs --retore-from m5out/performance > ./genome_roi_lock -g256 -s16 -n16384 -t1

   

   再开一个窗口，查看gem5统计的数据(gem5/m5out/stats.txt)

   1	> cat -n stats.txt | grep -E 'system.bigCluster.clk_domain.clock|simSeconds|system.bigCluster.cpus.power_model.dy*|system.bigCluster.cpus.power_model.st*'

   

4. 从ondemand中恢复,然后开始执行程序

   1 2 3 4 5 6 7 8 9 10 11 12 13 14

   > build/ARM/gem5.opt \ --debug-flags=dvfs_handler,EnergyCtrl \ --debug-file=dvfs_debug.log \ configs/example/arm/fs_power.py \ --kernel=../full_system_for_gem5/binaries/vmlinux_4.4 \ --cache \ --dvfs \ --big-cpu-clock 3GHz 2GHz 1GHz 900MHz \ --big-cpu-voltage 1.0V 0.9V 0.8V 0.5V \ --little-cpu-clock 2GHz 1GHz 800MHz 500MHz \ --little-cpu-voltage 1.0V 0.8V 0.6V 0.5Vs --retore-from m5out/ondemand > ./genome_roi_lock -g256 -s16 -n16384 -t1

   

   

   • 从statistic可以看出，在跑程序之前CPU工作在最低频率下，即图中的clock=1111(900MHz)；当进入程序时，governor将CPU频率从1111变化到333(即3GHz)，以最高频率工作。当工作完成后，CPU继续以3GHz进行程序的收尾部分，然后在某一瞬间，变化到1GHz(1000)，如果后续没有负载则在这个过渡态待一会儿，又将CPU调度到900MHz工作。

     

5. 结果比较

   | dvfs调度策略 | 时间(s) | 动态功耗(w) | 静态功耗(w) |
   | :——————: | :———: | :————-: | :————-: |
   | performance | 0.004403 | 1.65 | 93.84 |
   | ondemad | 0.007800 | 0.05 | 5.3 |

   • 由于Ondemand将cpu调整到3GHz，有延迟并且需要转换时间，而Performance策略CPU一直在3GHz运行，因此Ondemand运行的时间更长。
   • 由于本次实验只是想通过DVFS达到控制频率点的目的，对于CPU还有其它模块的动静态功耗公式只是用单一指标简单示意(比如动态功耗定义成与电压成正比，静态功耗定义成与温度成正比)，没有进行详尽的建模和修正，所以计算得到的结果只能比较相对值，绝对值没有意义。
   • 在Performance的调度策略下，CPU一直处于最高频率下工作，温度会较低频率更高。因此静态功耗会更高。又因为越高的频率所需的电压越高，其动态功率也会越大，与最后得到的实验结果相一致。

5.5 遗留问题

1. 为什么只有CPU0(即大核)能够应用DVFS，而CPU1(小核)不能动态调整频率。

   

   通过查看dvfs_debug.log文件，可以看到系统成功初始化两个domain域，大核域id为0；小核域id为1。并且初始化的电压-频率点与命令行手动输入的相吻合。由此判断DVFS的底层驱动是正确的。但是/sys/devices/system/cpu/文件夹下只有cpu0提供上层模块用户接口的cpufreq文件夹，而cpu0却没有，猜测可能的原因是目前官方提供的内核的dvfs高层驱动只支持挂载一个域。

2. 为什么在performance下运行benchmark只输出一组数据，而在Ondemand下输出四组数据。

   通过反复实验观察，gem5会默认每隔1s的仿真时间dump一次数据。可以通过m5.stats.periodicStatDump覆盖默认的dump周期(见5-1)。其次gem5内部实现了一种机制，只要一个域的频率发生了变化就dump一次数据(目前还没有找到办法禁掉该特性)。再者运行benchmark时，在程序ROI结尾也会自动dump一次数据。

6 总结

• gem5是一个高度模块化，参数化的性能仿真器。
• gem5一直在更新迭代，对原有模型进行补充并不断有新的模型和特定应用扩展加入gem5主线
• 通过阅读相关文献，了解到用户在gem5中可以定制化建模硬件，并和其它现有的模型连接成系统，在这个虚拟的系统中运行未经修改或者修改后的操作系统或应用程序。
• 通过DVFS实验，学习到了gem5的全系统模式仿真，命令行参数配置，复杂系统的python配置文件编写等。

参考资料

• [1] Mukherjee, S. et al. “Performance Simulation Tools.” Computer 35 (2002): 38-39.
• [2] Binkert N, Beckmann B, Black G, et al. The gem5 simulator [J]. SIGARCH Comput Archit News, 2011, 39(2): 1–7.
• [3] gem5官方介绍和相关教程https://www.gem5.org/
• [4] Presented by Andreas Sandberg Nikos Nikoleris, Arm at the Arm Research Summit 2017
• [5] V. Spiliopoulos, A. Bagdia, A. Hansson, P. Aldworth, and S. Kaxiras, ‘Introducing DVFS-Management in a Full-System Simulator’, in Proc. 21st International Symposium on Modeling, Analysis and Simulation of Computer and Telecommunication Systems, 2013.

YOLO, aka “You Only Look Once”—> 名字是不是很酷

YOLO是object detection领域非常出名的算法，它以速度快同时兼顾性能著称。

1 Net Architecture

• concatenate层在Yolo里面叫做route层
• res_unit层在Yolo里面叫做shortcut层
• detection层在Yolo里面叫做yolo层

2 Details

1. 输入层:416*416*3

2. 将输入划分为$S * S$ grid, 每个格子有三个预先设定好长($p_w$)和宽($p_h$)的anchor box；如果物体的中心落在哪个grid, 那个grid就负责探测该物体。

   

3. 每个anchor box有85个数据[$t_x, t_y, t_w, t_h, objectscore, c1, c2…]$，分别代表：

   • 预测框中心点坐标：网络实际输出的是$t_x 和 t_y$, 为了让该cell预测的物体中心一定落在该cell上，加了个sigmoid函数。
   • 预测框长和宽: 防止梯度下降不稳定，所以进行了对数空间变换，网络给出$t_x, t_h$, 真实的长和宽由👆公式计算。
   • 是否有物体的概率: 如果没有物体，后续类别的置信分数将没有作用
   • 一共预测80个类别，每个类别的置信分数。

1. 有三种scale的输出层，分别为：13 * 13 * 85；26 * 26 * 85；52 * 52 * 85；

   每个cell有三个anchor box;所以每个输入一共有$(13\times13+26\times26+52\times52)\times3=10647$个预测框

2. 这么多输出框肯定绝大部分是重复预测或者不正确的预测，需要剔除不好的框

   • 设置object score阈值，比如低于0.6的去除
   • 设置IOU阈值，进行Non-maximum Suppression

Implementation in PyTorch

Reference

1. how-to-implement-a-yolo-object-detector-in-pytorch
2. YOLO V1: You Only Look Once: Unified, Real-Time Object Detection
3. YOLO V2: YOLO9000: Better, Faster, Stronger
4. YOLO V3: An Incremental Improvement
5. IOU
6. Bounding Box Regression (Appendix C)
7. Non maximum suppresion
8. PyTorch Official Tutorial

python opencv 包的官方网址: https://pypi.org/project/opencv-python/

opencv官网网址 : https://docs.opencv.org/master/

• 直接通过pip安装(有图形界面的PC)

  • 选择1：包含主要的模块: pip install opencv-python
  • 选择2: 全部安装(有些额外的模块) : pip install opencv-contrib-python

• 没有图形界面的服务器上(与👆对应)

  • pip install opencv-python-headless
  • pip install opencv-contrib-python-headless

• 尝试用conda install open-cv,但是找不到包

Common Usage

导入的包为cv2

1. 读取图像

1
2

import cv2
cv2.imread("dog.png")

返回值: 像素矩阵[height, width, channel]

类型: numpy.ndarray；

数据类型: unit8;

通道: BGR, 不是RGB; 可以通过src[:,:,::]转换

注意：每个像素的数据类型一定要uint8；否则会出现

error: (-215:Assertion failed) src_depth != CV_16F && src_depth != CV_32S in function ‘convertToShow’

解决办法: np.uint8(image)

2. 显示图像

1

cv2.imshow("winname", image)

3. 缩放图像

1

cv2.resize(src, dsize[, dst[, fx[, fy[, interpolation]]]]) --> dst

参数说明:

• src: 读入的图像, [height, width, channel]
• dsize: 变换后的宽和高(width, height) —> (int, int)
• dst: 与src相对应, 即变换完的各点像素矩阵
• fx: x方向(即width方向) 缩放倍数
• fy: y方向(即height方向)缩放倍数
• interpolation: 插值方法
• notes: 转换后的尺寸要么由dsize要么由fx,fy来决定

• 如果你已经创建了dst(转换后的尺寸由dst来决定)

  1	resize(src, dst.size(), dst)

• 修改图片尺寸

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

  import cv2 import numpy as np def letterbox_image(img, inp_dim): """resize image with unchanged aspect ratio using padding img: input image inp_dim: """ img_w, img_h = img.shape[1], img.shape[0] # img:[height, width, channel] w, h = inp_dim scale = min(w / img_w, h / img_h) # keep aspect ratio new_w = int(img_w * scale) # multiply the same number new_h = int(img_h * scale) # 表示大小时用的是(width,height) --> 返回的是[height, width, channel] resized_image = cv2.resize(img, (new_w, new_h), interpolation=cv2.INTER_CUBIC) # cubic cv2.imshow("unchanged aspect ratio", resized_image) canvas = np.full((h, w, 3), 128) # create a numpy array having shape of [width, height, c] # padding with (128,128,128) gray canvas[(h - new_h) // 2: (h - new_h) // 2 + new_h, (w - new_w) // 2:(w - new_w) // 2 + new_w, :] = resized_image return canvas if __name__ == "__main__": filename = "dog-cycle-car.png" dog = cv2.imread(filename) cv2.imshow("original_dog", dog) shrink_dog = cv2.resize(dog, None, fx=0.5, fy=1, interpolation=cv2.INTER_CUBIC) dog_keep_ratio_padding = np.uint8(letterbox_image(dog, (dog.shape[0] // 2, dog.shape[0] // 2))) # height/2 cv2.imshow("dog_keep_ratio_padding", dog_keep_ratio_padding) cv2.imshow("shrink_dog", shrink_dog) cv2.waitKey(0) cv2.destroyAllWindows()

  • 一定要使用cv2.waitKey(0)，否则显示不了图片:（正数为等待的时间,单位毫秒)
  • 使用cv2.destroyWindows(“winname”),可以主动关闭窗口(图片)

  

4. 在图像上画矩形)

1

cv2.rectangle(img, pt1, pt2, color[, thickness[, lineType[, shift]]]) -> img

The function cv::rectangle draws a rectangle outline or a filled rectangle whose two opposite corners

are pt1 and pt2

pt1,pt2: 两个对角的坐标

color: tuple(R,G,B)

thickness: int 如果为负数,比如-1,那么会填充整个矩形

lineType: 8(默认)：8连接；4：4连接线；CV_AA:锯齿线

注:对于整数坐标的非反锯齿线，使用8连接或4连接的Bresenham算法。粗线以圆角结尾绘制。反锯齿线是用高斯滤波绘制的

shift: 点坐标中的小数位数

5.在图像上写字

1

cv2.putText(img, text, org, fontFace, fontScale, color[, thickness[, lineType[, bottomLeftOrigin]]])

对于不能渲染的symbol，使用？标记

text: String to be drawn

org: Tuple(x,y) Bottom-left corner of the text string in the image(文本的左下角坐标)

fontFace: 字体

fontScale: 字体大小

color, thickness, lineType: 同👆

bottomLeftOrigin: 当其为真时，图像原点在左下角，否则在左上角(opencv默认为左上)【如果为True，字翻转$180^o$】

1
2
3
4
5
6
7
8
9
10
11

enum HersheyFonts {
    FONT_HERSHEY_SIMPLEX        = 0, //!< normal size sans-serif font
    FONT_HERSHEY_PLAIN          = 1, //!< small size sans-serif font
    FONT_HERSHEY_DUPLEX         = 2, //!< normal size sans-serif font (more complex than FONT_HERSHEY_SIMPLEX)
    FONT_HERSHEY_COMPLEX        = 3, //!< normal size serif font
    FONT_HERSHEY_TRIPLEX        = 4, //!< normal size serif font (more complex than FONT_HERSHEY_COMPLEX)
    FONT_HERSHEY_COMPLEX_SMALL  = 5, //!< smaller version of FONT_HERSHEY_COMPLEX
    FONT_HERSHEY_SCRIPT_SIMPLEX = 6, //!< hand-writing style font
    FONT_HERSHEY_SCRIPT_COMPLEX = 7, //!< more complex variant of FONT_HERSHEY_SCRIPT_SIMPLEX
    FONT_ITALIC                 = 16 //!< flag for italic font
};

6 示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

import cv2


if __name__ == "__main__":
    filename = "imgs\\dog.jpg"
    dog = cv2.imread(filename)
    cv2.imshow("original_dog", dog)
    c1 = (164, 108)
    c2 = (560, 447)
    color = (255, 0, 0) # red
    cv2.rectangle(dog, c1, c2, color, 2, lineType=cv2.LINE_AA)
    cv2.imshow("rectangle", dog)
    label = "bicycle"
    # (text,fontFace,fontScale,thickness)
    t_size = cv2.getTextSize(label, cv2.FONT_HERSHEY_SIMPLEX, 1, 1)[0] # 
    c2 = c1[0] + t_size[0] + 3, c1[1] - t_size[1] - 4 # c2 at the right-top of original rectangle's top-left corner
    # (width:x, height:y)
    cv2.rectangle(dog, c1, c2, color, -1, lineType=cv2.LINE_AA) # -1 fill the rectangle
    cv2.putText(dog, label, (c1[0], c1[1]-6), cv2.FONT_HERSHEY_SIMPLEX, 1, [225, 255, 255], 1)
    cv2.imshow("rectangle+text", dog)
    cv2.waitKey(0)
    cv2.destroyAllWindows()

依赖分为：托管依赖「managed」和非托管依赖「unmanaged」

Unmanaged

非托管依赖：比如JAR包

使用方法：

• 把需要的JAR包拷贝到项目根目录的lib文件夹 下。
• 如果该JAR包还依赖其它JAR包，你也要下载其它JAR并把其同样拷贝到lib目录中

缺点：

• 要自己解决包依赖关系，一旦项目变大了，靠手工维护基本不可能

Managed(key)

托管依赖：通过给定项目一些属性，由构建工具(如sbt)自动去默认仓库下载。

Single lib

基本语法: 写在项目的「build.sbt」文件中

1

libraryDependencies += groupID % artifactID % revision % configuration

最小完整的文件:

1
2
3
4
5
6
7

name := "BasicProjectWithScalaTest"  // 项目名称

version := "1.0"                     // 项目版本

scalaVersion := "2.10.0"             // 项目Scala版本

libraryDependencies += "org.scalatest" %% "scalatest" % "1.9.1" % "test"

• 👆方法说明：

example：👇两个等效

1
2

libraryDependencies += "org.scalatest" % "scalatest_2.10" % "1.9.1" % "test"
libraryDependencies += "org.scalatest" %% "scalatest" % "1.9.1" % "test"

libraryDependencies可以在sbt默认远程仓库中找到

notes:

• 假设你添加一个依赖，但是这个工件依赖其它的工件，那么sbt会自动帮你下载依赖，这是非托管无法比拟的
• 工件的版本很总要;一定要与自己项目中Scala版本兼容
• SBT使用Apache Ivy作为自己的依赖管理器，而Ivy也被Ant和Maven使用，因此能在Scala项目中很容易使用多年来创建的丰富Java库。
• SBT使用standard Maven repository作为默认仓库(索引的工件数截至2020/12/03已经是18.4M); 如果你需要的库没有发布到改标准库中，你必须告诉SBT去哪里寻找，这个过程通过添加一个resolver解决

Multiple lib

• 使用Seq方法（注意是++=）

  1 2 3 4 5

  libraryDependencies ++= Seq( "net.sourceforge.htmlcleaner" % "htmlcleaner" % "2.4", "org.scalatest" % "scalatest_2.10" % "1.9.1" % "test", "org.foobar" %% "foobar" % "1.8" )

  Multiple project

• 使用lazy：构建多个项目

  

• 使用projects：查看项目结构

• 使用.dependsOn:主项目依赖可以移到子项目中，然后显示指明

  1	.dependsOn(helloCore) // 表示依赖子项目

• 使用dist：生成通用jar包

  • 在~/project/plugins.sbt添加插件 『~代表项目根目录』

    1	addSbtPlugin("com.typesafe.sbt" % "sbt-native-packager" % "1.3.4") // 添加sbt-native-packager插件,用于打包universal package

  • 在build.sbt中添加JavaAppPackaging

    1	.enablePlugins(JavaAppPackaging) // 用于打包dist?

    

• 使用publishlocal: 把包发布到本地

  • 默认是在~\.ivy2\local\文件夹下

  • 严格按照上述groupID % artifactID % revision % configuration来组织

    

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

  -com.example // groupID - hello_2.12 // artifactID - 1.0.0 // revision - docs - ivys - jars - proms - scrs - hello-core_2.12 // 子项目生成的工件 - 1.0.0 - docs - ivys - jars - proms - scrs - 0.1.0-SNAPSHOT(这是自前发布的) - docs - ivys - jars - proms - scrs

• 使用Docker/publishLocal:生成镜像

References

[1] sbt-by-example

[2] sbt-how-to-manage-project-dependencies-in-scala

[3] mvnrepo-chisel3-core

[4] Sbt 依赖配置

有很多构建工具，比如 Ant, Maven, Gradle等等，但是 sbt是专门为Scala设计的。它前些日子还被Scala创始人Martin Odersky联合创办的Lightbend公司支持。

What is sbt

sbt 是一个交互式构建工具:你可以在Scala project中定义你的task，然后从交互式sbt shell 并行的运行它们。

Why sbt

• 专为Scala和Java设计：它能使用多个Scala版本交叉编译你的项目。
• 类型安全和并行的build.sbt：一个基于Scala的DSL(domain specific language)，用于表示并行任务处理图谱。任何打字错误都会引发编译错误。
• 快速迭代：使用Zinc 增量编译器和文件监视器，使得编辑-编译-测试循环达到快速并且递增
• 可扩展性：我们只用在build.sbt中写入相应代码，就可以增加对新的任务或平台(比如Scala.js)的支持。
• Join 100+ community-maintained plugins to share and reuse sbt tasks

Install sbt(1.4.4)

• for windows

  • windows installer
  • universal package
  • 使用Chocolatey「Windows 平台包管理器」：> choco install sbt

• for linux

  • 推荐把sbt软件包发布的apt仓库加入到源列表

    

The sbt directory structure

• 手动创建项目目录

  1 2 3 4

  mkdir HelloWorld cd HelloWorld mkdir -p src/{main,test}/{java,resources,scala} mkdir project target

• ​ 使用sbt命令行工具

  1	sbt new scala/hello-world.g8 // 从Github仓库上拉下来项目模板

  

1
2
3
4
5
6
7
8

- hello-world
    - project (sbt uses this to install and manage plugins and dependencies)
        - build.properties
    - src
        - main
            - scala (All of your scala code goes here)
                - Main.scala (Entry point of program) <-- this is all we need for now
    - build.sbt (sbt's build definition file)

Running the project

1

sbt run

Project management

build.sbt文件非常重要，你项目的Scala版本，依赖项全在里面有说明。

添加依赖后，你才可以在你的程序里面正常import；

发布的包可以在这里查看

更多内容请见下一篇文章：【build.sbt 详解】😸

References

[1] Scala book

[2] GETTING STARTED WITH SCALA

[3] sbt reference

type for /? in your cmd.exe prompt

2 common usage¹

跟python里面迭代器发「iterator」很像，对一个集合的数据做相同的操作。

note:

• 如果是在命令行,那么使用%G;在脚本文件中使用%%G
• 如果迭代器每次产生一个值,那正好赋值为%%G
• 如果迭代器每次产生多个值,那么系统隐式定义几个变量来保存值，默认是按字母顺序:%%H %%I %%J…
• 如果迭代器产生文件，可以使用扩展符来提取文件名称/路径/日期/大小等

1 for

1	FOR %%parameter IN (set) DO command

• 把一系列文件拷贝到备份

1

FOR %%G IN ("C:\demo files\file1.txt" "C:\demo files\File2.txt") DO copy %%G d:\backups\

2 for /R

1	FOR /R [[drive:]path] %%parameter IN (set) DO command

• 如果省略[[drive:]path] 那么用当前的代替

• set必须使用通配符?和.

• 如果(set)为(.), 那么便利每个文件夹，不遍历文件^test

1. 列出从C:\temp\开始的每个子文件夹中的每个.bak文件

   1	For /R C:\temp\ %%G IN (*.bak) do Echo "%%G"

2. 将’demo’文件夹和所有子文件夹中的.LOG文件重命名为.TXT:

   1	For /R C:\demo\ %%G in (*.LOG) do Echo REN "%%G" "%%~nG.TXT"

3. 依次将目录更改为当前文件夹下的每个子文件夹(包含自己所在文件夹)²

   1 2 3 4 5

   FOR /R %%G in (.) DO ( Pushd %%G Echo now in %%G Popd ) Echo "back home"

3 for /D

1	FOR /D [/r] %%parameter IN (folder_set) DO command

在几个目录/文件夹上有条件地执行一个命令。

/r 递归的进入子文件夹

• 列出名称以“Users”开头的文件夹C:\Work\下面的每个子文件夹

  1 2 3

  @Echo Off CD \Work FOR /D /r %%G in ("User*") DO Echo We found %%~nxG

  4 for /L

1	FOR /L %%parameter IN (start,step,end) DO command

有条件地对一组数字执行命令。

• 从1数到5

  1	FOR /L %%G IN (1,1,5) DO echo %%G

• 非数值列表可以使用标准的for命令

  1	FOR %%G IN (Sun Mon Tue Wed Thur Fri Sat) DO echo %%G

• 给文件创建1000个副本

  1	FOR /l %%G in (1,1,1000) DO copy SourceFile.txt NewFile%%G.txt

  5 for /F

1 2 3

FOR /F ["options"] %%parameter IN (filenameset) DO command FOR /F ["options"] %%parameter IN ("Text string to process") DO command

针对文件里面的字符处理

options:(优先级：usebackq > skip > delims > eol > tokens)

1. delims=xxx(分隔符, 默认为空格)

2. skip=n （文件开头要跳过的一些行,默认为0)

3. eol=; (每行开头指示注释的字符，默认为分号;)

4. tokens=n (指定要从每行读取哪些编号的项,默认为1)

5. usebackq (使用交替引用的风格)

   

1. 如果”delims=”,那么把一行都视为第一个token
2. “eol=&” 一般把eol设置为不容易碰到的字符，避免把本该解释的行注释掉
3. “skip=3” 去掉前面三个空行
4. tokens用法:2,4,6, 2-6(2到6),*(所有), 3*(第4个起后面的)

• 复制文本文件中列出的文件到新的目的地:

  1 2	假设files.txt每行包含一个文件名 FOR /f "delims=" %%G in (files.txt) DO copy "\\source\folder\%%G" "H:\destination\%%G"

• 从包含字符和逗号的文本文件中提取数据

  文件如下：

  January,Snowy,02
  February,Rainy,15
  March,Sunny,25

  1	FOR /F "tokens=1,3 delims=," %%G IN (weather.txt) DO @echo %%G %%H

  结果如下：

  January 02
  February 15
  March 25

• 解析一段字符串

  1	FOR /F "tokens=4 delims=," %%G IN ("deposit,$4500,123.4,12-AUG-09") DO @echo Date paid %%G

  输出：Date paid 12-AUG-09

6 for /F

1	FOR /F ["options"] %%parameter IN ('command to process') DO command

命令解析：对命令的处理包括每次读取一行命令的输出，然后将该行分解为单个的数据项或“tokens”。然后执行DO命令，并将参数设置为找到的tokens。

使用场景：你想执行一些命令，把命令指令的结果提取出来并赋予变量，然后对该变量进行一系列操作

• 只打印环境变量，不打印其值

  1	FOR /F "delims==" %G IN ('SET') DO @Echo %G

• 把Windows版本设置为环境变量

  1	FOR /F "tokens=4*" %%G IN ('ver') DO SET _version=%%G

  输出结果：

  SET _version=10.0.19042.630]

  （其中命令env输出:Microsoft Windows [Version 10.0.19042.630])

• 列出一个文件夹中的所有文本文件，包括完整路径

  1	FOR /F "tokens=*" %%G IN ('dir/b /s ^"c:\program files\*.txt^"') DO echo %%G

References

安装Install意味着安装各种命令行工具「Scala compiler, coursier, sbt…」和构建工具「build tools」

2 how to install

有两种办法：

1. Scala Installer tool：自动安装所有依赖
2. 手动安装

① Scala Installer

Windows msi：获取安装包Scala-2.13.4(这种方法最简便, 跟Windows其它软件包安装方式一样)

或者下载coursier(Scala工件「artifact」获取器)

👇三种方法任选其一

1. 下载源代码(自己编译,打包成jar包)

2. 下载脚本+jar包

3. 下载二进制文件

方法二详解:

• 确保你有Java（运行Java —version)

  

• 确保环境变量设置正确✔(set JAVA_HOME=/path/to/java/installation)

  notes: 比如你java.exe在D:\app\jdk\bin\java.exe; 那就设置JAVA_HOME=D:\app\jdk即可,不要再加\

  

  脚本自动检测你电脑上的Java环境, 如果没有自动下载

  自动下载标准Scala应用程序到~\AppData\Local\Coursier\data\bin

② manually

• 下载Oracle Java 8\11
• 下载sbt
  • 👆coursier可以看成它的插件，用于解决包依赖问题
  • 为自己项目选定特定Scala版本，相应的包版本;sbt会帮你自动解决

3 check

1. 如果你用的msi安装包,默认安装在c/Program Files (x86)/scala/bin/下

2. 如果使用cs，那么在~/AppData/Local/Coursier/data/bin 下

   

References

Generate constructs are used to either conditionally or multiply instantiate generate blocks into a model

生成结构用于要么有条件地或成倍地实例化生成块到一个模型中。

有两种生成结构：loops和conditionals

loops: 用于实例生成块多次

conditionals: 包括if-generate和case-generate结构;最多从一系列generate blocks中选择一个.

Generate schemes are evaluated during elaboration of the model.

生成方法：决定哪个生成块被实例化或多少生成块被实例化的方法。

Elaboration occurs after parsing the HDL and before simulation(生成发生在解析HDL之后仿真之前);包括如下五个过程：

• expanding module instantiations
• computing parameter values
• resolving hierarchical names
• establishing net connectivity
• preparing the model for simulation

Loop generate constructs

loop生成结构运行使用类似for loop 的语法把一个生成块实例多次。循环索引变量应该在使用前用genvar声明；genvar只在elaboration时有用，所以你不能在生成块任何地方引用它。

1. 参数化

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

   module gray2bin1 (bin, gray); parameter SIZE = 8; // this module is parameterizable output [SIZE-1:0] bin; input [SIZE-1:0] gray; genvar i; generate for (i=0; i<SIZE; i=i+1) begin :bit assign bin[i] = ^gray[SIZE-1:i]; // i refers to the implicitly defined localparam whose // value in each instance of the generate block is // the value of the genvar when it was elaborated. end endgenerate endmodule

2. 使用二维net把生成的实例连接起来

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

   module addergen1 (co, sum, a, b, ci); parameter SIZE = 4; output [SIZE-1:0] sum; output co; input [SIZE-1:0] a, b; input ci; wire [SIZE :0] c; wire [SIZE-1:0] t [1:3]; genvar i; assign c[0] = ci; // Hierarchical gate instance names are: // xor gates: bit[0].g1 bit[1].g1 bit[2].g1 bit[3].g1 // bit[0].g2 bit[1].g2 bit[2].g2 bit[3].g2 // and gates: bit[0].g3 bit[1].g3 bit[2].g3 bit[3].g3 // bit[0].g4 bit[1].g4 bit[2].g4 bit[3].g4 // or gates: bit[0].g5 bit[1].g5 bit[2].g5 bit[3].g5 // Generated instances are connected with // multidimensional nets t[1][3:0] t[2][3:0] t[3][3:0] // (12 nets total) for (i=0; i<SIZE; i=i+1) begin :bit xor g1 ( t[1][i], a[i], b[i]); xor g2 ( sum[i], t[1][i], c[i]); and g3 ( t[2][i], a[i], b[i]); and g4 ( t[3][i], t[1][i], c[i]); or g5 ( c[i+1], t[2][i], t[3][i]); end assign co = c[SIZE]; endmodule

3. multilevel generate loop

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

   parameter SIZE = 2; genvar i, j, k, m; generate for (i=0; i<SIZE; i=i+1) begin :B1 // scope B1[i] M1 N1(); // instantiates B1[i].N1 for (j=0; j<SIZE; j=j+1) begin :B2 // scope B1[i].B2[j] M2 N2(); // instantiates B1[i].B2[j].N2 for (k=0; k<SIZE; k=k+1) begin :B3 // scope B1[i].B2[j].B3[k] M3 N3(); // instantiates B1[i].B2[j].B3[k].N3 end end if (i>0) begin :B4 // scope B1[i].B4 for (m=0; m<SIZE; m=m+1) begin :B5 // scope B1[i].B4.B5[m] M4 N4(); // instantiates B1[i].B4.B5[m].N4 end end end endgenerate // Some examples of hierarchical names for the module instances: // B1[0].N1 B1[1].N1 // B1[0].B2[0].N2 B1[0].B2[1].N2 // B1[0].B2[0].B3[0].N3 B1[0].B2[0].B3[1].N3 // B1[0].B2[1].B3[0].N3 // B1[1].B4.B5[0].N4 B1[1].B4.B5[1].N4

   Conditional generate constructs

条件生成结构只能选择一个生成块

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

module  test;
parameter  p = 0, q = 0;
wire  a, b, c;
//---------------------------------------------------------
// Code to either generate a u1.g1 instance or no instance.
// The u1.g1 instance of one of the following gates:
// (and, or, xor, xnor) is generated if
// {p,q} == {1,0}, {1,2}, {2,0}, {2,1}, {2,2}, {2, default}
//---------------------------------------------------------
if  (p == 1)
   if  (q == 0)
     begin  : u1          // If p==1 and q==0, then instantiate
       and  g1(a, b, c); // AND with hierarchical name test.u1.g1
     end
   else   if  (q == 2)
     begin  : u1          // If p==1 and q==2, then instantiate
       or   g1(a, b, c); // OR with hierarchical name test.u1.g1
     end
                   // "else" added to end "if (q == 2)" statement
   else ;                                   // If p==1 and q!=0 or 2, then no instantiation
else   if  (p == 2)
   case  (q)
  0, 1, 2:
     begin  : u1         // If p==2 and q==0,1, or 2, then instantiate
            xor  g1(a, b, c);// XOR with hierarchical name test.u1.g1
          end
   default :
     begin  : u1          // If p==2 and q!=0,1, or 2, then instantiate
       xnor  g1(a, b, c);// XNOR with hierarchical name test.u1.g1
     end
   endcase
endmodule

External names for unnamed

尽管一个没有名字的生成块没有可以被使用的阶级名字(hierarchical name)，但是它需要一个名字让外部接口可以访问它。因此出于该目的将会给他们分配名字。

所有没名字的生成块将被给予genblk<n>名字,其中是被分配到它包括的生成结构的次数。（从1开始计数）；如果有冲突,在前面加0直到不冲突为止

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

module  top;
   parameter  genblk2 = 0;
   genvar  i;
  // The following generate block is implicitly named genblk1
   if  (genblk2)  reg  a;  // top.genblk1.a
   else                    reg  b;  // top.genblk1.b
  // The following generate block is implicitly named genblk02
  // as genblk2 is already a declared identifier
   if  (genblk2)  reg  a;  // top.genblk02.a
   else                    reg  b;  // top.genblk02.b
  // The following generate block would have been named genblk3 
  // but is explicitly named g1
   for  (i = 0; i < 1; i = i + 1)  begin  : g1    // block name
    // The following generate block is implicitly named genblk1 
    // as the first nested scope inside of g1
     if  (1)      reg  a;  // top.g1[0].genblk1.a
   end
  // The following generate block is implicitly named genblk4 since 
  // it belongs to the fourth generate construct in scope "top". 
  // The previous generate block would have been 
  // named genblk3 if it had not been explicitly named g1
   for  (i = 0; i < 1; i = i + 1)
    // The following generate block is implicitly named genblk1 
    // as the first nested generate block in genblk4
     if  (1)      reg  a;  // top.genblk4[0].genblk1.a
  
  // The following generate block is implicitly named genblk5
   if  (1)        reg  a;  // top.genblk5.a
endmodule

The blog is derived from the transition of JupyterLab document

Preface

JupyterLab is the next-generation web-based user interface for Project Jupyter.

JupyterLab enables you to work with documents and activities such as Jupyter notebooks, text editors, terminals, and custom components in a flexible, integrated, and extensible manner.

jupyterlab是下一代基于web的Jupyter项目用户界面；它能让你以灵活、集成和可扩展的方式与文档和活动一起工作，比如notebook，文本编辑器，终端还有自定义组件。

Installation

1. prerequisite

   安装notebook

   1	conda install -c conda-forge notebook

2. 安装jupyterlab

   1	conda install -c conda-forge jupyterlab

   Start

3. 在conda prompt中敲如下命令

   1	jupyter lab

4. jupyter lab会自动在浏览器中打开

   1	http(s)://<server:port>/<lab-location>/lab

   因为JupyterLab是jupyter notebook一个服务器扩展，所以你也能够通过调用jupyter notebook并访问/lab URL来登录JupyterLab。

5. 如果👆有问题,多半是kernel有问题;

   首先尝试建立一个干净的jupyter环境

   1 2 3

   conda create -n jlab-test --override-channels --strict-channel-priority -c conda-forge -c anaconda jupyterlab// 创建一个新的环境 conda activate jlab-test// 切换到该环境 jupyter lab // 启动jupyterlab

The blog is derived from the transilation of conda document: https://docs.conda.io/projects/conda/en/latest/

Preface

Package, dependency and environment management for any language—-Python, R, Ruby, Lua, Scala, Java, JavaScript, C/ C++, FORTRAN

对python, R等语言其包，依赖和环境的管理

1、基本功能

• Conda是一个开源包管理系统和环境管理系统,可以运行在Windows, MacOS, Linux上.
• Conda能够快速安装,运行,升级包和包的依赖.
• Conda能轻易地在本地创建,保存和切换环境.
• conda起初是为Python程序创建,但它能打包和发布(package and distribute)其它语言的软件.

2、应用场景

1. Conda作为包管理器，帮助你找到并安装你需要的包。如果您需要一个需要不同版本Python的包，你不需要切换到另一个环境管理器，因为conda也是一个环境管理器(environment manager)。只需要一些命令，你就能建立一个完全独立的环境去运行不同版本的python，同时在正常环境中继续运行您通常版本的Python
2. 在conda默认的配置中，conda能够在repo.anaconda.com安装和管理超过7500个包;这些包被Anaconda®构建、评审和维护.
3. Conda可以与Travis CI和AppVeyor等持续集成系统相结合，为代码提供频繁的自动化测试。

3、获取Conda

1. 通过下载Anaconda®, Miniconda, and Anaconda Repository
2. 通过Anaconda Enterprise(收费)
3. Conda is also available on conda-forge, a community channel
4. You may also get conda on PyPI, but that approach may not be as up to date.

4、Anaconda

anaconda is a graphical user interface that lets you use conda in a web-like interface without having to enter manual commands

anaconda有图形界面，对用户更加友好,但内核还是conda

Getting stated

1、打开命令行

如果是Windows,最好用anaconda prompt,貌似cmd也可;Linux就直接在terminal输命令即可.

1. 如果不是最新的，建议更新到最新

   1 2 3

   conda --veriosn 4.9.0 conda updata conda

   如果👆不起作用：出现了RemoveError 使用如下命令：

   1	conda update --force-reinstall conda(重新安装)

   2、创建一个环境

   Conda允许您创建包含文件、包及其不与其他环境交互的依赖项的独立环境。

   当你开始使用conda，就已经有一个默认的环境base;但是,您不希望将程序放到基本环境中。创建单独的环境，使您的程序彼此隔离。

   • 创建一个新的环境,并在其中安装一个包.

     1	conda create --name snowflakes numpy

     conda随后会检查是否有额外的包(“dependencies”)是numpy所需,并问你是否要继续:

     1	Proceed ([y]/n)? y

     输入”y”并按Enter继续.

     

   • 切换到刚刚创建的环境

     1 2 3 4 5 6

     conda info --envs [-e] // 查看已有的环境列表(带*表示当前环境) # conda environments: # base D:\APP\miniconda py38 D:\APP\miniconda\envs\py38 snowflakes * D:\APP\miniconda\envs\snowflakes

     1	conda activate snowflakes // 切换到环境snowflakes

• 修改刚刚创建的环境的名字

  1 2	conda create -n new_name --clone old_name conda remove -n old_name --all

3、管理包

在这部分，你将学会检查你安装了哪些包, 检查哪些包是可以得到的，并查找一个特定的包并安装它。

• 激活一个环境

• 检查你没有安装的”beautifulsoup4”是否在Anaconda repository中存在.(你必须联网)

  1	conda search beautifulsoup4

  conda会列出包含那个包名的所有包,这样你就知道它们是可以得到的。

• 安装此包到当前环境中

  1	conda install beautifulsoup4=4.9.1

• 检查新安装的程序是否在这个环境中:

  1	conda list

  

关于使用conda的最重要信息的单页摘要。

conda cheat sheet PDF (1 MB)

Installation

最快的安装方法是:安装Miniconda(400MB)

• 它是免费的conda最小安装包

• 仅仅包含conda，Python，packages they depend on，还有一些非常有用的包(包括pip, zlib等等).

• 需要使用conda install命令从Anaconda repository安装额外的7500+包(anaconda直接安装好)

• Miniconda是一个Python发行版，它可以使安装Python变得又快又容易，甚至对新用户也是如此。

  

note：你没有必要为了使用conda去卸载掉你系统中原先的python和相应的包.

我们只需要正常安装miniconda,并让安装程序将conda installation of Python添加到PATH环境变量中.没有必要设置PYTHONPATH环境变量。

• for windos:

  安装包下载地址:https://docs.conda.io/en/latest/miniconda.html#windows-installers

• for linux

  • 使用脚本

  1 2 3 4 5

  wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh // 获取安装脚本 echo "<sha-hash> *filename" | shasum -a 256 -c // 检测文件完整性 echo "879457af6a0bf5b34b48c12de31d4df0ee2f06a8e68768e5758c3293b2daf688 *Miniconda3-latest-Linux-x86_64.sh" | sha256sum -c Miniconda3-latest-Linux-x86_64.sh: OK // 完整性正常 bash Miniconda3-latest-Linux-x86_64.sh // 安装脚本

  • 使用包管理器(apt或者npm)

Managing channels

Conda channels are the locations where packages are stored. They serve as the base for hosting and managing packages. Conda packages are downloaded from remote channels, which are URLs to directories containing conda packages. The conda command searches a default set of channels and packages are automatically downloaded and updated from https://repo.anaconda.com/pkgs/

Conda通道是存放包的位置；不同的通道可以有相同的包，所以conda必须处理这些通道冲突。

Conda列出从所有通道收集到的具有相同名称的包，并按照如下方式处理它们:

• 按通道优先级排序
• 再按版本号排序;
• 再按构建号排序；
• 安装排序列表中满足安装规范的第一个包。
• channelA::numpy-1.13_1 > channelA::numpy-1.12.1_1 > channelA::numpy-1.12.1_0 > channelB::numpy-1.13_1(如果打开了严格通道排序，那么channelB的包就不会在此列表中)

1
2
3
4

conda config --prepend/add channels new_channel // 优先级最高
conda config --append channels new_channel      // 优先级末尾
conda config --set channel_priority false       // 优先级关闭,那么每次安装最新版本
或者把`channel_priority: false`添加到`.condarc`文件中

添加清华的channel(将下面代码复制到.condarc文件中):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

channels:
  - defaults
show_channel_urls: true
channel_alias: https://mirrors.tuna.tsinghua.edu.cn/anaconda  
default_channels:
  - https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main
  - https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/free
  - https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/r
  - https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/pro
  - https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/msys2
custom_channels:
  conda-forge: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud
  msys2: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud
  bioconda: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud
  menpo: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud
  pytorch: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud
  simpleitk: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud

• 默认channel_alias为:https://repo.anaconda.com/pkgs/

• 通常,default_channels指向repo.anaconda.com存储库中的几个通道，但是如果定义了default_channels，它将设置默认通道的新列表。这对airgapped和企业安装非常有用。

• 为了确保所有的用户从内部部署的仓库拉取包，管理员可以设置👆两个参数。

• channel_alias: 在以后你指定channel不是url时,会加上这个前缀

• 如果要下载的包清华源没有，在anoconda的存储库中，可以在custom_channel加上相应的通道

  1 2 3 4 5 6 7

  peterjc123: https://conda.anaconda.org // 简写为 conda install -c peterjc123 vc vs2017_runtime // 否则要写全 conda install --channel https://conda.anaconda.org/peterjc123 vc vs2017_runtime // 也可以写成 conda install -c defaults https://conda.anaconda.org/peterjc123 vc vs2017_runtime

  

The blog is derived from the translation of ARM IHI 0011A AHB specification Copyright © 1999 ARM Limited

文档链接：https://pan.baidu.com/s/19fG2h8Jw4k29AjWfRBliFw 提取码：mmme

0 Convention

0.1 timing parameters

generic timing parameters that are required to analyze an AMBA design

• Tis - input setup time

• Tih - input hold time

• Tov - output valid time

• Toh - output hold time.

0.2 timing diagrams

Notes：

• 总线和信号中的阴影区域是未定义的，所以可以假定他们在这个区域的值是任意的。它们实际的值不重要，不影响正常的操作。
• 单比特信号有时在同一时刻被显示为HIGH和LOW，它们和总线变化(👆Bus change)相似。如果单比特信号像这样显示，意味着它的值不影响附带的描述(accompanying description)

1 Slave

slave对系统内master发起的传输做出响应。slave使用解码器传来的HSELx信号来决定合适对传输做出响应。所有其它被传输需要的信号，例如地址和控制信号，都有master产生。

17.1 Interface diagram

17.2 Timing diagrams

17.2.1 Reset

• Tihrst：reset输入信号保持时间[在时钟边沿后还得保持一段时间保证被采样到] (ih=input hold time; rst=HRESETn)

• Tisrst：reset输入信号建立时间[在时钟边沿之前维持valid一段必要的时间，让主触发器能够采样到✔的值]

17.2.2 Normal signals

• Tovrdy：输出信号HREADY的有效时间

17.2.3 Additional signals

2 Master

在AMBA系统中，master有最复杂的总线接口。通常来说，一个AMBA系统设计者会使用预先设计好的master(可能是处理器核，协处理器等)，因此没必要担心master接口的细节。

2.1 Interface diagram

3 Arbiter

在AMBA系统中仲裁器的角色：控制哪个master有权访问总线。每个master有一个通向仲裁器的REQUESET/GRANT接口，仲裁器使用一个优先级策略决定当前请求总线的所有master中哪个优先级最高。

每个master也会产生一个HLOCKx信号，用来向master指示我需要对总线独占访问。(exclusive access to the bus)

优先级别策略的细节没有规定，而是每个应用自己决定。对于仲裁器使用其它的信号(例如AMBA或non-AMBA)去影响正在使用的优先级策略是可以接受的。

3.1 Interface diagram

4 Decoder

AMBA系统中的decoder用于完成一个中心化地址译码的功能，通过使它们独立于系统内存映射(system memory map)来提高外设可移植性。

The blog is derived from the translation of ARM IHI 0011A AHB specification Copyright © 1999 ARM Limited

文档链接：https://pan.baidu.com/s/19fG2h8Jw4k29AjWfRBliFw 提取码：mmme

0 Overall framwork

1 Bus interconnection

AHB总线协议被设计成带有一个中心选择器(central multiplexor)的互连方案。

• 主设备驱动地址和控制信号，信号指示它们想要执行的传输。
• 并且仲裁器决定哪个主设备能够把他们的信号路由给所有的从设备；
• 还需要一个中心译码器控制读数据(read data)和回应信号(response signal)多选器，它从涉及这次传输的从设备中选择合适的信号。

2 Overview of operation

在一次传输开始(commence)之前，master必须被授予访问总线(granted access to the bus)。这个过程由master向仲裁器发起一个请求信号开始(assert a request signal)。然后仲裁器指示何时将授予master总线使用权。

得到授予的master通过驱动地址和控制信号开始一次AHB transfer。这些信号提供了关于地址，方向，传输宽度和这次传输是否是burst的一部分的指示信号(indiction)。两种不同形式的burst transfer都被允许：

• 递增的突发(incrementing burst)，它不包装在地址边界
• 包装的突发(wrapping burst)，包裹在特殊的地址边界

写数据总线把数据从master搬运到slave；但读数据总线把数据从Slave搬运到master。

每次传输都包括如下两个部分：

• 一个地址和控制周期(an address and control cycle)
• 一个或多个数据周期(one or more cycle for the data)

由于地址不能被扩展(extended)，所有所有的从设备必须在此期间取样地址。但是数据可以用HREADY信号扩展。当该信号为低时导致等待状态(wait states)被塞进这次传输里面；因此允许slave有额外的时间取提供或者采样数据。

在传输中，slave通过response signal传达状态信息，HRESP[1:0]：

• OkAY：指示传输进展正常，当HREADY变高时，该信号指示传输成功完成(complete successfully)
• ERROR：指示传输❌发生，传输失败
• RETRY and SPLIT：两者都表示传输不能立刻完成，但是master应该继续尝试传输。

notes:在正常操作中，允许master在仲裁器授予其它master访问总线前完成一次burst的所有传输。但是，为了避免过多的(excessive)仲裁延迟，有可能仲裁器会打断一次burst，在这种情况下，master必须重新向仲裁器申请总线以完成burst中剩余的传输。

3 Basic transfer

3.1 simple without wait

一次AHB传输包含两个不同的部分(two distinct sections)：

• The address phase, which lasts only a single cycle
• The data phase, which may require several cycles. This is achieved using the HREADY signal.

👆没有等待状态的简单传输

• master在HCLK上升沿把地址和控制信号驱动到bus上
• slave在下一个上升沿采样地址和控制信号
• 在slave采样完成之后，它开始驱动合适的回应信号，然后response被master在三个上升沿采样。

notes: 事实上，任何传输的地址相与前一个传输的数据相发生在同一时期。正是因为这种重叠，它们构成了总线流水特性，为高性能操作提供契机，同时为slave对接收的数据做出反应提供了足够的时间。

3.2 simple with wait

notes: Ⅰ、对于写操作，master需要在扩展周期一直保持稳定的数据；Ⅱ、对于读操作，slave不需要一直提供有效数据，直到传输将要完成。

3.3 multiple transfers

• 地址A和地址C的传输没有等待状态
• 地址B的传输有一个等待状态
• 地址B传输中的数据phase扩展对地址C传输的地址phase扩展有影响。

4 Transfer type

每一种传输都可以被归类为以下四种中的一种，用HTRANS[1:0]信号指示

5 Burst operation

4，8，16节拍的bursts在AHB协议中有定义，除此之外还有没有定义长度的bursts和单个的传输；递增和包裹的阵发传输都被支持：

• 递增的阵发访问顺序的位置，突发中的每个传输的地址只是先前地址的一个增量。
• 对于封装阵发，如果传输的起始地址没有对齐阵发的总字节数(size * beats)，那么传输地址将包裹当达到边界时(trap when the boundary is reached)。例如，一个4-beat的包裹阵发以字(4-byte)访问将封装在16-byte的边界。因此如果传输的起始地址为Ox34，那么它由四次传输组成，每次地址为Ox34, Ox38, Ox3C, Ox30

Table 4-1 Burst signal encoding

• 阵发不能跨越1KB的地址边界(即A[9:0]=0)。因此对于master不要尝试开始一个固定长度递增阵发，让这个界限被跨越。
• 使用没有指定长度的阵发，并且只有一个长度为1的阵法来代替single transfers。
• 一个递增阵发可以是任何长度,但是上限被1KB设定

notes: ①阵发的大小是每个阵发节拍的数量，不是传送的字节数。一个burst传送的总的数据量=节拍数*每个节拍数据量(HSIZE[2:0])②：在一次burst中的所有传输必须对齐地址边界，（边界等于传输的大小)；例如，字传输必须对齐字地址边界(A[1:0]=00字地址的地两位为0；即表示地址是4的倍数)，半字传输必须对齐半字地址边界( A[0] = 0(地址的最后一位为0;即表示地址是2的倍数))。

5.1 early termination

有很多情形，阵发不能完成；因此对于slave的设计中，充分利用阵发信息在阵发提前终止时采取正确的行动很重要。slave可以通过监视HTRANS信号确定阵发何时提前终止，确保阵发开始后的每一个传输都被贴上SEQUENTIAL或者BUSY标签。如果带有NONSEQUENTIAL或者IDLE的传输出现，那表明新的阵发开始并且之前的阵发一定被终止了。

如果master不能完成一个阵发，因为它失去了总线拥有权，那么它必须在它下次获得权限时合适地重新建立阵发。例如，如果一个master仅仅完成了4-beat阵发中的一个beat，那么它下次必须使用undefined-length阵发来完成剩余的三个阵发。

5.2 4-beat

notes: 因为是传送大小4-byte的4-beat阵发；①for warping：地址要封装在16-byte的边界内；因此地址为Ox3C的传输后紧跟的是地址为Ox30的传输。②：for increment: 它可以跨越16-byte边界。

5.3 8-beat

可以看到地址边界为：8*4=32；那么整个地址空间被分割成很多包含32个字节的块；00-1F; 20-3F; 40-5F….；由于起始地址为OX34——>被封装在Ox20-3F这块里面；

5.4 xx-beat

• 两个半字传输从地址Ox20开始，地址每次增加2
• 三个字传输从地址Ox5C开始，地址传输增加4

6 Control signals

和传输类型和阵发类型一样，每次传输都有许多控制信号，这些信号提供了传输的额外信息。这些控制信号有着和地址总线完全相同的时序。但是，它们必须在整个阵发期间保持恒定.(remain constant)

6.1 Transfer direction

当HWRITE为高，信号指示一个写传送，并且master在写数据总线上广播数据(HWDATA[31:0])。当其为低时，一个读传送将执行，slave必须在读数据总线上生成数据(HRDATA[31:0])。

6.2 Transfer size

Hsize[2:0]指示传送的大小。

这个大小(transfer size)用于和HBURST[2:0]信号联结起来决定wrapping bursts的地址边界

6.3 Protection control

控制保护信号HPROT[3:0]，提供了关于总线访问的额外信息，主要是为了想要实现某种保护的模块使用。

这个信号指示这次传输为：

• 取操作码\ 数据访问
• 特权模式访问\ 用户模式访问

对于带有内存管理单元的master，这些信号还可以指示当前的访问是否可缓存(cacheable or bufferable)

notes: 并不是所有的master都有能力生成正确保护信息，因此推荐slave不要使用HPROT信号的信息，除非严格需要(strictly necessary)。

7 Address decoding❓

中心化的地址译码器(central address decoder)为总线上每一个slave提供一个选择信号，HSELx。选择信号是高阶地址信号的组合译码，简单地址译码方案鼓励使用来避免复杂译码逻辑，并且可以保证高速操作。

当HREADY信号为高时(指示当前传输完成)，slave一定仅采样地址，控制信号和HSELx。在特点情景下，HSELx信号可能在HREADY为低的时被声明(发出)，但是所选slave在当前传输完成时将会改变。

❓能够分配给单个slave的最小地址空间为1kB。所有的master都被设计成不允许执行跨越1KB边界的递增传输(incrementing transfers)，因此确保burst永远不会越过地址译码边界。

在系统设计不包含一个完全填充的内存映射的情况下，一个额外的默认slave应被实现，以提供一个响应时，任何不存在的地址位置被访问。如果NONSEQUENTIAL或者SEQUENTIAL传输尝试一个不存在的地址位置，那么默认的slave应该提供一个ERROR响应。IDLE或者BUSY传输尝试一个不存在的地址位置时，应该返回零等待状态的OKAY响应。默认slave的功能通常由decoder的一部分完成。

8 Slave response

在master开始一个传输后，slave随即判断传输改怎样进展，在AHB spec中没有[当传输开始后，master可以取消传输]的规定。

无论slave何时被访问，它一定提供一个response,指示传输的状态。HREADY信号用于扩展传输，它还和响应信号HRESP[1:0]组合提供传输状态。

slave可以用多种方法完成传输：

1. 立即完成
2. 插入一个或多个等待状态匀出时间来完成
3. 发送一个error信号告知传输失败
4. 延迟传输的完成，但是允许master和slave让出总线，腾给其它传输使用。

8.1 transfer done

HREADY信号用于扩展AHB传输的数据部分。当拉低该信号时表明传输被扩展，当拉高该信号表示传输完成

note: 为了计算访问总线的延迟时间，每个master必须有一个预先确定的等待状态的最大数目，它将在退出总线之前插入。我们推荐但不强制：每个slave不要插入超过16个wait states，以防任何单个访问🔒住总线过多的时钟周期。

8.2 transfer response

通常，slave使用HREADY信号来插入合适的数量的wait states，并在传输完成时置高HREADY，返回OKAYresponse，指示传输成功完成。

ERROR response用于指示某种形式的传输失败。很典型的是保护错误，例如尝试写入只能读的存储区域。

SPLIT和RETRY响应组合让slave能延迟传输的完成，但是释放总线给其它master用。这些响应组合通常仅仅被那些访问延迟长的master使用，充分利用这些响应码可以确保其它的master申请bus不会等待太长的时间。

note: 当slave发现还不能立刻给出响应结果，需要插入几个等待周期时，它应该响应OKAY

8.3 Two-cycle response

只有OKAY响应才可能出现在单周期中。ERROR，SPLIT和RETRY响应至少需要两个周期。为了用这些响应中的任何一个来完成传输，在倒数第二个周期，slave驱动HRESP[1:0]指示ERROR, RETRY or SPLIT，同时驱动HREADY低电平来扩展一个额外的周期。在最后一个周期HREADY驱动到高电平结束这次传输，但是HRESP[1:0]仍然保持不变指示ERROR, RETRY or SPLIT。

如果slave需要多于两个周期来提供ERROR, RETRY or SPLIT响应，那么额外的等待状态在传输的开始被插入。等待期间HREADY=0，响应设置为OKAY

由于总线流水线的特性，需要两个周期的响应。这时slave开始发射 ERROR, SPLIT or RETRY中的任何一个响应，然后下一次传输的地址已经被广播到总线上。两周期的响应给master足够的时间取消地址，在下一次传输开始前驱动HTRANS[1:0]到IDLE。

对于SPLIT和RETRY响应，接下来的传输一定被取消，因为在当前传输完成前不能进行此传输。但是，对于ERROR响应，其中当前传输没有重复时，完成接下来传输的是可选的。

8.3.1 retry

• master开始一个地址A的传输
• 在这次传输的响应收到前，它开始新的传输A+4
• 在地址A的slave不能立刻完成改次传输，因此它回复RETRY响应；这个响应告诉master地址A的传输不能完成，所以地址A+4的传输被取消并用IDLE传输替代。

8.3.2 Error

• slave需要一个周期决定响应(此期间HRESP指示OKAY)
• 然后slave用两周期的ERROR响应终止该传输

8.4 Error response

如果一个slave提供一个错误响应，然后master可以选择取消在突发的剩余传输。但是，这不是一个严格的要求，并且master继续在突发中传输剩余的数据也是可以接受的。

8.5 Split and retry

分割和重试响应提供了一种机制，当slave不能立即为传输提供数据时，可以释放总线。这两种机制都允许在总线上的传输完成，因此允许高优先级的master访问总线。

两者的不同在于仲裁器分配总线的方法：

• 对于retry：仲裁继续使用正常的优先级策略，因此只有更高优先级的master能获得总线
• 对于split：仲裁器调整优先策略，以至于任何申请的master都有机会获得，即使是那些低优先级的。为了完成SPLIT的传输，仲裁器必须被通知slave何时准备好了数据。

SPLIT传输需要同时在仲裁器和slave上增加复杂度，但是它的优势在于它完全释放总线给其它masters, 与此相对的是retry，它只释放总线给优先级更高的master。

master应该用同样的方式对待SPLIT和RETRY。它应该继续申请总线，尝试传输直到它要么成功完成，要么它以ERROR响应提前终止了。

9 Data buses

为了AHB系统实现不需要使用三态驱动器(tristate drivers)，我们需要独立的读和写数据总线。最小的数据总线宽度被指定为32 bits，但是可以增加。

9.1 HWDATA[31:0]

写数据总线在写传输期间由master驱动。如果传输被扩展，master保持数据有效直到传输完成(由HREADY 变高指示)

对于比起总线宽度还窄的传输，比如在32位总线上传输16位，那么master只用驱动适当的字节通道（byte lanes)。slave负责为写进的数据选通正确的字节通道。👇表格说明哪个字节通道分别在大端和小端系统中被激活。如果需要，此信息可以扩展为更宽的数据总线实现。对于传输大小小于数据总线宽度的阵发传输，每一拍有不同的激活字节通道。

激活字节通道取决于系统是大端还是小端，但是AHB没有指定所需的端。因此，对于系统中的master和slave保持相同的端很重要。

9.2 HRDATA[31:0]

读数据总线在读传输中被对应的slave驱动。如果slave扩展传送，那么slave仅仅需要提供有效的数据在传输的最后一个周期，用HREADY=1指示

对于比总线宽度更窄的传输，slave仅仅需要在激活的字节通道上提供有效的数据。master负责从正确的字节道中选择数据

slave只要当传输带有OKAY响应完成时提供有效数据。 SPLIT, RETRY and ERROR responses不需要提供有效读数据。

9.3 Endianness

为了让系统功能正确，所有模块使用同样的端很重要，并且所有的数据路由或者桥也用一样的。

动态端不支持，因为绝大多嵌入书系统，这将导致大量冗余的硅开销(silicon overhead that is redundant)

对于某块设计者，我们推荐只有那些可被用在许多地方的模块才应该设计成大小端，要么带有可配置的引脚(pin)或者内部控制位取选择端的大小。对于更多特定应用的模块，固定端为小端或者大端可以节省功耗，提高接口性能。

10 Arbitration

仲裁机制被用来确保任何时候只有一个master访问总线。仲裁器通过观察一些不同的请求，判断当前请求中最高优先级的master来完成这一功能。仲裁也接受来自slave的请求，请求完成SPLIT传输。

任何不能完成SPLIT传输的slave都不需要知道仲裁的过程，除非它们需要观测这样的事实——一连串的传输可能无法完成如果总线所有权改变了。

10.1 Signal description

• HBUSREQx ：总线请求信号；每个master有单独的请求信号连接到仲裁器，最多有16个独立的master。
• HLOCKx ：锁信号与请求信号被master同时发出；它指示我将要执行大量不可分割的传输，并且一旦带🔒传输的第一个传输开始，仲裁一定不要授权其它的master。该信号一定在它访问的地址之前至少一个周期发出，以免仲裁改变了授权信号。
• HGRANTx ：授权信号由仲裁生成，指示当前申请总线的master中优先级最高的，考虑锁传输和SPLIT传输在内。
• HMASTER[3:0]：指示当前谁有权利使用总线。该信号还被用来当作地址控制多选器的控制信号。master的号码还被能够执行SPLIT传输的slaves使用，来向仲裁指示哪一个master能够完成SPLIT交易
• HMASTLOCK：仲裁器通过发出该信号指示当前传输是带🔒传输序列的一部分，其与地址和控制信号有相同的时序。
• HSPLIT[15:0] ：能够处理split的slave使用16bit的SPLIT Complete bus来指示哪个master能够完成split交易。仲裁器需要这个信息来授权master去完成该次传输。

10.2 Requesting bus access

master使用HBUSREQx信号来请求访问总线，并可能在任何周期发起请求。仲裁器将在时钟上升沿取样请求信号然后使用内部优先级算法决定哪个master将成为下一个有权利访问总线的。

正常来说仲裁器只会当阵发完成后才授权一个不同的master。但是，如果需要，仲裁器能提前终止一次阵发来让更高优先级的master访问。

如果master需要锁访问，那么它必须发送HCLOKx信号来向仲裁器指示：不该有其它的master被授权。

当有一个master被授权总线并正在执行一个固定长度长度的阵发，它没必要持续请求总线来完成阵发。仲裁器观察阵发的进程并使用HBURST[2:0]信号知道master请求了多少次传输。如果master希望在当前正在进行的burst之后再执行第二次burst，那么它应该在当前burst期间重新发出请求信号

如果一个master在阵发中途失去了总线访问权，那么它必须重新发出HBUSREQx请求来重新获得总线访问权。

对于没有定义长度的burst，master必须持续发出请求知道它开始了最后一次传输(until it has started the last transfer)。在没有定义长度阵发的末尾，仲裁器不能预测何时去改变仲裁。

当master不请求总线时，它可能被授予该总线。这种情况发生在没有master请求总线并且仲裁器授予访问权给一个默认的master。因此，如果master不需要访问总线，它应该驱动传输类型HTRANS指示当前传输为IDLE。

10.3 Granting bus access

10.3.1 granting with wait

仲裁程序通过声明适当的HGRANTx信号来指示当前请求总线中哪个master是最高优先级的。当当前传输完成，有HREADY为高来指示，之后master将被授权并且仲裁器会改变HMASTER[3:0]信号来指示这个master的号码。

• 当master发出HBUSREQx后几个周期，仲裁器才授权(HGRANTx置高)
• master只有等到HGRANTx和HREADY都为高才开始传送地址。同时HMASTER[3:0]指示该master
• 地址被slave采样，当HREADY为高时才传送下一个地址。

10.3.2 Data bus owner

• 数据总线拥有权滞后于地址总线。(👆落后T5和T6两周期)
• 无论传输何时完成(由HREADY为高指示)，那么拥有地址总线的master(👆#2在T7可以传送写数据)将能够使用数据总线，并一直占有数据总线直到传输完成。

10.3.3 handover after burst

• 仲裁器在倒数第二个地址被采样完(👆T5)改变HGRANTx信号，新的HGRANTx信号将和阵发的最后一个地址信号在相同时刻被采样(👆只有HREADY为高时才采样成功即T7；此时HMASTER也改为#2)。

10.3.4 hgrant and hmaster

• 因为有中央复用器，每一个master都能够驱动它们想要立刻执行的传输的地址，并且它们直到被授予总线才需要等待。
• HGRANTx信号仅仅被master用于决定它们何时拥有总线，因此什么时候它应该考虑地址已经被适当的slave取样。

10.4 Early burst termination

正常来说，仲裁器不用移交总线给一个新的master，直到阵发传输的结束。但是，如果仲裁器认为阵发应该提前终止为了避免访问总线时间过长，那么它可能在阵发完成之前转换授权给另外一个master。

10.5 default bus master

每个系统一定包含一个默认的master，它在其它master都不能访问总线时被授予使用。当被授予时，默认master一定只能进行IDLE的传输。

如果没有master请求总线，那么仲裁器要么授权默认的master，要么授予可能从访问总线低延迟获益最大的master。

授予对总线默认的master访问权还提供了一种有用的机制，以确保总线上不会启动新的传输，是在进入低功率工作模式之前执行的一个有用的步骤

⭐如果所有其它master都在等待分割传输完成，则必须授予默认master。

11 Split transfer

SPLIT传输通过分离master向slave提供地址的操作和slave向master提供正确数据的操作，来提高总的总线利用率。

当一次传输发生时，slave如果相信该次传输需要花费很多周期去执行，那么它将发送SPLIT响应。这个信号告诉仲裁器当前尝试传输的master不应该被授权直到slave表示它已经准备好完成传输。因此仲裁器需要观测响应信号并在内部屏蔽来自已被分割(have been SPLIT)的master的任何请求

在一次传输的地址相中，仲裁器产生一个标签或者master编号HMASTER[3:0]，指示正在执行传输的master。任何发出SPLIT响应的slave必须能够指示它们有能力完成传输，并且它通过记录HMASTER[3:0]信号上的master编号来做到这一点

随后，当slave完成了传输，它根据master编号在HSPLITx[15:0]上向仲裁器发出合适的位。仲裁器然后使用该信息unmask(停止屏蔽)对应master的请求信号并在适当的适合(in due course)master被授权访问来重启之前的传输。仲裁器每周期都取样HSPLITx信号，因此slave只需要发出合适的位持续一个周期以便仲裁器能够识别它。

在带有多个有能力发送SPLIT的slave系统中，来自每个slave的HSPLITx信号被或操作到一起，产生一个最终结果的HSPLIT信号给仲裁器。

在大多数系统中，可能用不到16个master的最大容量。因此仲裁器只需要一根HSPLIT总线，其位数与master个数相同。但是，我们推荐所有有能力发送split的slave都被设计成支持最多的16个master。

11.1 split transfer seq

SPLIT交易的基本阶段如下：

1. master以和其他任何传输相同的方式开启传输，并发射地址和控制信息。
2. 如果slave能够立刻提供数据，它可能这样做。如果slave决定它可能需要多个周期获得数据，它将给出一个SPLIT响应。在每次传输中，仲裁器广播一个号码或者标签—指示正在使用总线的master。slave必须记录这个号码，后面用这个信息重启这个传输。
3. 仲裁器授权其它master，并且SPLIT响应的动作允许master切换的发生。如果所有其它的master也收到了SPLIT响应，那么默认的master被授权。
4. 当slave准备好完成传输时，它发出合适的HSPLITx中的位给仲裁器指示哪个master被授权访问总线。
5. 仲裁器每个周期都会观察HSPLITx信号，并且当HSPLITx中任何一位被声明时，仲裁器恢复该master的优先级(因为之前被屏蔽了)
6. 最终仲裁器授权该master，好让它能够重新尝试这次传输。如果一个更高优先级的master正在使用，上述场景可能不会立刻发生。
7. 当传输最终发生时，slave用OKAY响应结束这次传输。

11.2 multiple split trans❓

该总线协议仅允许每个master有一个滞外交易/未完成事物(outstanding transaction)。如果任何master模块能够处理不止一个滞外交易，他需要为每个它能处理的滞外交易提供一组额外的请求和授权信号。在协议级别上，单个模块可以作为许多不同的master出现，每一个master只能有一个滞外交易。

❓但是，一个有能力处理SPLIT的slave可能接收比它所能并发处理更多的传输请求。如果这种情况发生，slave发送SPLIT响应，但没有记录与传输对应的地址和控制信息是可接受的，slave只是必须记录master的编号。通过为所有之前有split传输关联的master声明HSPLITx中合适的位，然后slave指示它可以处理另一个传输，但是slave没有记录地址和控制信息。

然后仲裁器能够重新授权master访问，它们也就能够重新尝试传输，给予slave所要求的地址和控制信息。这意外着master在它最终被允许完成它请求的传输前需要被授权许多时间(a number of time)。

11.3 preventing deadlock

SPLIT和RETRY响应使用时一定要避免死锁。单个传输不可能锁住AHB,因为每个slave一定被指派在预先规定的周期内去完成传输。但是，如果大量不同的master尝试访问同一个slave，这个slave以不能处理的方式发射SPLIT和RETRY响应时可能发生死锁。

11.3.1 Split

对于能够发射split响应的slave，总线死锁通过确保slave能够经受得住系统中每个master的请求来避免(最多16个)。slave没必要保存每次传输的地址和控制信息，它仅仅需要记录这样的事实：一次传输请求已经发出，并且一个SPLIT响应也发出。最终所有的master都将在一个较低优先级，然后slave可以有序地处理这些请求，向仲裁器指示它正在处理哪个请求，因此保证所有的请求最终都被完成。

当一个slave有许多未完成的请求，它可以选择以任何次序去处理它们，尽管slave一定要注意锁定的传输(locked transfer)必须在任何其它传输可以继续之前完成。

理想情况下，master的未完成传输量不应该超过它所能支持的传输量，但是需要这种机制来防止总线死锁。

11.3.2 Retry

对于发送RETRY响应的slave每次只能由一个master访问。这不是由总线的协议强制执行的，应该由系统体系结构确保。大多数情况下，发送RETRY响应的slave可能是那些一次只有一个master访问的外围设备，所以能够被更高级别协议确保。

对多master访问RETRY slaves的硬件保护不是本协议的要求，但可按下一段所述实现。在总线级别上，只要求slave一定要在预定数量的时钟周期内驱动HREADY到高电平。

如果需要硬件保护，那么可以在RETRY slave本身上实现。当一个slave发射一个RETRY，它能采样master号码。在该时刻和传输最终被完成之间，slave检查每个传输尝试，以确保是相同的master号码。如果它检测到主编号不同，那么它可以采取另一种操作过程，例如：

• ERROR响应
• 发送仲裁器一个信号
• 系统级别中断(a system level interrupt)
• 系统重置(a complete system reset)

11.4 Bus handover

协议要求master在接收分割(split)或重试(retry)响应后,立即执行一次IDLE传输好让总线被转交给另一个master。

• T1之后传输的地址出现在总线上；在T2和T3时钟沿后slave返回两个周期SPLIT响应
• 第一个响应周期结束，T3，master检测到传输被分割(be SPLIT)所以它改变下一次传输的控制信号为IDLE。
• 同时在T3，仲裁器采样响应信号并发现传输将是SPLIT。然后仲裁器能够调整仲裁优先级，并且grant信号在接下来的一个周期发生改变，以至于新的master能够被授权地址总线在T4之后。
• ⭐新master被保证立刻访问，因为IDLE传输总是在一个周期完成。

12 Reset

HRESETn是AHB文档中唯一的低电平有效的信号，并且是所有总线元件的主要复位。复位可异步声明，但是在HCLK上升沿之后同步失效(deasserted)。

在复位期间，所有master确保地址和控制信号都在有效状态并且HTRANS[1:0]指示IDLE。

13 Data bus width

在不提高操作频率下，提高总线带宽的一种方法是提高总线数据通道宽度。金属层的增加和大片内存储块的使用(例如嵌入的DRAM)都是鼓励更宽总线的使用的驱动因素。

指定一个固定宽度的总线意味着，在许多情况下总线的宽度对于应用不是最优的。因此，我们采用灵活的总线宽度，但是任然保证模块在设计之间具有高度的可移植性(highly portable)

AHB协议允许数据总线为8，16，32，64，128，256，512或者1024bits。但是，我们推荐最小总线宽度为32bits,预计最大256bits将对绝大多数应用都是足够的。

对于读和写传输，接收模块必须从总线上正确的字节通道选择数据。不需要跨所有字节通道复制数据。

14 narrow slave on wide bus

👇图展示了一个原本被设计成处理32位数据总线的slave模块，是如何被轻松转换为处理64位总线。这仅仅需要额外的外部逻辑，而不需要任何内部设计的改变，因此这项技术也可以被用到硬宏单元。

对于输出，当转化窄的总线到一个宽的总线，做下面中的一条：

• 将数据复制到宽总线的两个部分(像👆)
• 使用额外层次逻辑确保总线只有合适的半部分改变。这可以节约能耗。

15 wide slave on narrow slave

👇图展示了一个宽接口的slave被实现在一个窄的总线上。

problem link：https://hdlbits.01xz.net/wiki/Count_clock

Background

时钟是每个人每天都会用到的工具，那怎么用电子电路搭建一个12-hour(带有am/pm指示)的时钟呢？

Problem description

选择一系列合适的计数器。你的计数器统一被快时钟(fast-running clock)驱动, 还带有一个脉冲使能输入，该脉冲会在任何需要时钟加1的时候到来（i.e.，每秒来一次)

• reset：重置时钟到12：00：00 AM
• pm is 0 for AM and 1 for PM
• hh:mm:ss：都各自代表两位BCD(用四位二进制表达一位十进制)数；
• hh(hours)：01-12；mm(minutes)：00-59；ss(seconds)：00-59
• reset比enable有更高的权限，即使在使能信号无效的时候也可以值位。
• 👇：从11:59:59 AM 到12:00:00 PM翻转和同步复位，使能的行为。

Hint：Note that 11:59:59 PM(晚上转钟) advances to 12:00:00 AM, and 12:59:59 PM（中午快1点了) advances to 01:00:00 PM. There is no 00:00:00.

Template

1
2
3
4
5
6
7
8
9
10
11

// Module Declaration
module top_module(
    input clk,
    input reset,
    input ena,
    output pm,
    output [7:0] hh,
    output [7:0] mm,
    output [7:0] ss); 
   
endmodule

Answer

① 1位BCD计数器

1. 复位到0：为分钟，秒计数器服务

   1 2 3 4 5 6 7 8 9 10 11 12 13

   /************** 1位BCD计数器,复位到0;实现0-9的循环 ***************/ module bcdreset0 ( input clk, input reset, // Synchronous active-high reset input enable, output [3:0] q); always @ (posedge clk) begin if(reset) q <= 4'h0; else if(!enable) q <= q; else if(q == 4'h9) q <= 4'h0; else q <= q + 4'h1; end endmodule

2. 复位到2：为小时低位服务(x->2)[⭐此处有特殊情况]

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

   /************************* 1位BCD计数器，复位到2；实现0-9的循环 *************************/ /************** 个位为2时：当高位为1，下一次应该是1；但是当高位为0，下一次为3 **************/ module bcdreset2 ( input clk, input reset, // Synchronous active-high reset input flag,// 指示当前为特殊情况，即为12的时候 input enable, output [3:0] q); always @ (posedge clk) begin if(reset) q <= 4'h2; else if(!enable) q <= q; else if(flag) q <= 4'h1;// 特殊情况 else if(q == 4'h9) q <= 4'h0; else q <= q + 4'h1; end endmodule

3. 复位到1：为小时高位服务(x->1)[⭐此处有特殊情况]

   1 2 3 4 5 6 7 8 9 10 11 12 13

   /*********** 1位BCD计数器，复位到2；实现0-1的循环 *************/ /*********** 每次使能到来，小时高位要么从0->1；要么从1->0;逻辑对应代码第11行***********/ module bcd_zero_one( input clk, input reset, input enable, output [3:0] q); always @ (posedge clk) begin if (reset) q <= 4'h1; // (复位为12； 高位为1） else if (!enable) q <= q; else q[0] <= ~q[0]; // 0变为1，1变为0(0000->0001) end endmodule

   ② 两位BCD计数器

4. 秒，分钟计数器：实现0-59循环；复位为0

   1 2 3 4 5 6 7 8 9 10 11 12 13

   /**************** 两位BCD(8-bit)数表示0-59 ;循环到59时能不能下一个计数到0 **************/ module zero2fifty_nine( input clk, input reset, input ena, output [7:0] ss); wire ena_ten, reset_ten; assign reset_ten = (((ss == 8'h59) & ena) | reset)? 1'd1:1'd0;⭐// 当计数到59且下一个使能到来时，把高位置为到0；因为低位肯定回到0;如果不reset，那么肯定为60 assign ena_ten = ((ss[3:0] == 4'h9) & ena)?1'd1:1'd0;⭐ // 个位到9(重点:必须使能到来)才能使能十位(假设现在为29分:00秒,分钟的十位使能必须在60s后才会到来;但是不并上使能,那么下一秒将是39分:01秒 decade_counter one (clk, reset, ena, ss[3:0]);// 4位二进制表示个位的0-9 decade_counter ten (clk, reset_ten, ena_ten, ss[7:4]);// 4位二进制表示十位的0-9 endmodule

5. 小时计数器：实现1-12循环，复位为12

   1 2 3 4 5 6 7 8 9 10 11 12 13

   /************* 两位BCD(8-bit)数表示1-12;循环到12时能不能下一个计数到1 ***************/ /* ⭐(flag12) 小时个位为2时：当高位为1(12)，下一次应该是1；但是当高位为0(02)，下一次为3 */ module one2twelve( input clk, input reset, input ena, output [7:0] hh); wire ena_ten, flag12; assign ena_ten = (ena & ((hh == 8'h9)|(hh == 8'h12)))? 1'd1:1'd0;// 小时高位的改变信号(09->10;12->01) assign flag12 = (hh == 8'h12);// 指示当前为12 BCDreset2 one (clk, reset, flag12, ena, hh[3:0]);// 4位二进制表示个位的0-9 BCDzero_one ten (clk, reset, ena_ten, hh[7:4]); // 4位二进制表示十位的0-1 endmodule

   ③ 实例化三个②

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

module top_module(
    input clk,
    input reset,
    input ena,
    output pm,
    output [7:0] hh,
    output [7:0] mm,
    output [7:0] ss); 
wire ena_hr, ena_min, ena_pm;
    one2twelve hour (clk, reset, ena_hr, hh);
    zero2fifty_nine minite(clk, reset, ena_min, mm);
    zero2fifty_nine second(clk, reset, ena, ss);
    assign ena_min = (ss==8'h59)?1'd1:1'd0;// 当59s时才使能分钟计数器;
    assign ena_hr = ((mm == 8'h59) & (ss == 8'h59))? 1'd1: 1'd0;// 当59分59s才使能小时计数器
    assign ena_pm = ena_hr & (hh == 8'h11);  // 当11时59分59s才能改变pm⭐
    always @ (posedge clk) begin
        if (reset) pm <= 1'd0;
        else if(ena_pm) pm <= ~pm;   // 每当时钟转到11:59:59pm都会变换一次
        else pm <= pm;
    end
endmodule

problem link：https://hdlbits.01xz.net/wiki/Exams/ece241_2014_q7b

Background

从频率为1000Hz的时钟中得到频率为1Hz的信号(OneHertz)，它用来驱动一系列时/分/秒计数器的使能信号(Enable signal)以此创建一个数字时钟墙(digital wall clock)。因为需要时钟每秒计数一次，OneHertz信号必须每秒准确地断言一个周期(周期为1秒，且每周期只能翻转一次)。

Problem Description

用BCD计数器和少许其它的门构建分频器(frequency divider)。并且输出你所使用的BCD计数器的使能信号。(c_enable[0] for the fastest counter, c_enable[2] for the slowest)

如下的BCD计数器已经提供给你，Enable为高电平计数器才能正常工作，Reset为同步高电平置位0；

1 2 3 4 5 6

module bcdcount ( input clk, input reset, input enable, output reg [3:0] Q );

你设计的电路中所有的计数器必须直接使用相同的1000Hz时钟信号。

Template

1
2
3
4
5
6
7

module top_module (
    input clk,
    input reset,
    output OneHertz,
    output [2:0] c_enable
); 
    

First Try

answer

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

module top_module (
    input clk,
    input reset,
    output OneHertz,
    output [2:0] c_enable
); 
    reg [3:0] Q0,Q1,Q2;
    /************ BCD十进制,当Q=1001时使能-->十倍频 ***************/
    assign c_enable[0] = 1'b1;// 让第一个计数器全速计数
    assign c_enable[1] = Q0[3] & Q0[0];// 第二计数器计数周期是第一个的10倍
    assign c_enable[2] = Q1[3] & Q1[0]; // 第二计数器计数周期是第二个的10倍
    assign OneHertz = Q2[3] & Q2[0];
    bcdcount counter0 (clk, reset, c_enable[0], Q0); 
    bcdcount counter1 (clk, reset, c_enable[1], Q1);
    bcdcount counter2 (clk, reset, c_enable[2], Q2);
endmodule

result❌

• 在计数90-99的时候: c_enable[2]本该为0却变为了1，导致输出c_enable=5=3’b101;

• 由于c_enable[2]=Q1[3] & Q1[0]，起初我认为是Q1有问题；后续画出如下草图发现还是c_enable有问题

  

• 由于Q1是由计数器生成的，只要使能信号没问题，那么它就还🆗
• 又由于使能信号1和2是我们定义，所以从这里下手解决问题比较方便；
• 由上图知使能信号2有问题，它在计数90-99期间一直为高电平，我们只希望其在99时为高电平。
• 所有修改使能2的赋值：c_enable[2] = Q1[3] & Q1[0] & c_enable[1]
• 同理我们也要修改OneHertz = Q2[3] & Q2[0] & c_enable[2];，让其只在999时才有效；否则其在900-999一直有效；

Final answer

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

module top_module (
    input clk,
    input reset,
    output OneHertz,
    output [2:0] c_enable
); //
    reg [3:0] Q0,Q1,Q2;
    assign c_enable[0] = 1'b1;
    assign c_enable[1] = Q0[3] & Q0[0];
    assign c_enable[2] = Q1[3] & Q1[0] & c_enable[1]; 
    assign OneHertz = Q2[3] & Q2[0] & c_enable[2];
    bcdcount counter0 (clk, reset, c_enable[0], Q0); 
    bcdcount counter1 (clk, reset, c_enable[1], Q1);
    bcdcount counter2 (clk, reset, c_enable[2], Q2);
endmodule

Advanced problem(❓)

⭐如何实现50%(xx%)占空比的10(xx)倍频电路

1 Preface

• RV32I是为了足够成为编译器目标并能支持现代操作系统环境而设计的一个基本整数指令集。它也为了减少硬件实现的最小需求而设计。RV32I包含40个独立的指令，尽管一些简单的实现可能用单一的系统硬件指令（a single SYSTEM hardware instruction)代替ECALL/EBREAK指令，它总是捕获异常(always traps)并且可能将FENCE指令实现为NOP，以减少指令数到38个。RV32I能够模拟几乎任何的ISA扩展（除了A扩展，它需要额外硬件支持原子操作(atomicity）

• 在实践中，包含机器模式特权架构的硬件实现将需要9个CSR指令。

• 基本整数指令集的子集也许对于教学目的很有用(pedagogical purposes), 但是基础已经被定义，对实现其子集的真正的硬件除了忽略非对齐内存访问并把所有的SYSTEM instruction视为单一的异常(single trap)，我们不应该有什么其它的动机。

---

关于RV32I的大多注释也适用于RV64I base。

2 Programmer’s Model

对于RV32I非特权状态一共有32个寄存器(都是32位宽，i.e. ,XLEN=32)：x0~x31;x0被硬编码到0。另外31个寄存器保存的值可以被解释为：Ⅰ、布尔值的集合，Ⅱ、补码的有符号二进制整数，Ⅲ、无符号二进制整数

有一个额外的非特权寄存器，pc(program counter)：保存当前指令的地址

• 在Base Integer ISA中，没有指定的栈指针或者子例程返回地址链接寄存器(link register)；指令编码允许任何寄存器被用于这个目的；但是，标准软件调用惯例(calling convention)使用寄存器x1保存调用的返回地址，x5作为备用链接寄存器。标准调用例程使用x2作为栈指针(stack pointer)
• 硬件可以使用x1或x2来加速函数调用和返回(因为可以尽早解码)；详情见JAL和JALR指令
• 可选的压缩16-bit指令格式基于这样的假设设计的：x1：返回地址寄存器；x2:栈指针。使用其他约定的软件将正常运行，但可能有较大的代码大小。

notes：

• 可用架构寄存器(available architectural registers)的数量能够对代码大小，性能，能耗产生重大影响。尽管16个寄存器对于运行编译代码的整数ISA来说是足够的，但是在长度为16位使用3-address格式的指令中编码拥有16个寄存器完整的ISA是不可能的。(⭐PS:16个寄存器，address至少4位，三地址就12位，那么只剩下4位区分不同的指令了,即最多16条不同的指令)。
• 尽管2-address是可能的。但它增加指令条数并且降低效率。我们想要避免立即数指令的大小来简化硬件实现，一旦32-bit的指令大小被采用，支持32个整数寄存器就很显而易见了。一个更大数量的整数寄存器也有助于提高高性能代码的性能，可广泛使用循环展开（loop unrolling)、软件流水线(software pipelining)和缓存平铺(cache tiling)。❓
• 基于上面这些原因，我们为基础ISA选择了一个常规大小（conventional size)——32个整数寄存器。动态寄存器使用趋向于被一些经常访问的寄存器主宰，并且regfile(寄存器堆)的实现可被优化以减少频繁访问寄存器的访问能量(access energy)。
• 可选的16位压缩指令格式绝大部分只使用8个寄存器，因此能提供稠密的指令编码(dense instruction encoding),但是如果想要的话，额外的指令集扩展能支持更大的寄存器空间(要么扁平的要么分层次的)。

3 Base Instruction Formats

有4种核心的指令格式：R/I/S/U。指令长度都是32位，并且必须在内存中以4字节为边界对齐。指令地址非对齐的异常，常常是由于分支的发生(taken branch)或者非条件跳转的目标地址不是4字节对齐。

• 对于解码一个保留指令的行为是没有规定的(unspecified)

• RISC-V ISA保持源寄存器(rs1和rs2)和目标寄存器(rd)的位置在所有指令格式中相同以简化解码。除了使用在CSR指令中的5bit的立即数，立即数总是sign-extended，通常是打包到指令中最左边的可用位，这样分配以减少硬件的复杂程度。特别是，对于所有立即数的符号位总是在最高位(也就是Ins[31])来加速符号扩展电路。

  
  

  imm[x]指的是当前位在扩展成32位立即数中的位置
  • 实际应用中，大部分立即数要么很小，要么需要所有的位数(XLEN bits)。我们选择非对称立即数分割：常规指令中立即数占12bits;特殊的 load-upper-immediate 指令中立即数占20bits。这样做是为了给常规指令更多的opcode空间。

4 Immediate Encoding

指令格式还有两个变种(variants)：B/J，它们基于立即数的处理衍生出来。

• S和B仅有的区别：在B格式中12bit立即数域乘以2用于编码分支偏移。而不是像传统做法那样，将指令编码中的所有立即数位用硬件左移一位,中间的位数(imm[10:1])和符号位保留在固定位置，而S格式中的最低位(inst[7])在B格式中编码一个高阶位。
• U和J的仅有区别：U要向左移12位；而J只用移动1位。在U和J指令立即数中指令的位置尽量跟其他格式的指令或者它们互相重叠。

5 Computational

大多数的整数算术指令(Integer computational instruction)对保存在整数寄存器中的XLEN位的值进行操作。整数计算指令要么被编码为使用I格式的寄存器-立即数操作；要么使用R格式的寄存器-寄存器操作。对于这两种类型指令的目的寄存器都是rd。没有整型计算指令会导致算术异常

• 基本指令集不包括对整数算术运算上做溢出检查(overflow checks)支持的特殊指令集。因为许多溢出检查能够更便宜地(cheaply)使用RISC-V分支来实现

• 对无符号加法的溢出检查仅仅需要在加法指令后加上一条额外的分支指令

  1 2	add t0,t1,t2 blut t0, t1, overflow

• 对于有符号加法：如果一个操作数的符号已知，溢出检查仅需要加法之后的一个分支（覆盖了带有立即数操作数的常见加法情形）

  1 2	addi t0, t1, +imm blt t0, t1, overflow

• 对于常规的有符号加法，加法之后需要三条额外的指令。利用当且仅当另一个操作数为负时，该和应小于其中一个操作数的观察。

  1 2 3 4

  add t0, t1, t2 slti t3, t2, 0 slt t4, t0, t1 bne t3, t4, overflow

• 在RV64I中，32位有符号的加法溢出可以通过比较ADD和ADDW操作的结果来进一步优化。(ADDW肯定不会溢出)

Register-Immediate

1. ADDI：将12位立即数符号扩展后与rs1中的值相加，算术溢出忽略，结果的低32位存到rd寄存器中。

   1 2 3

   /* 两条指令等效 */ ADDI rd, rs1, 0 MV rd , rs1(汇编伪指令：将rs1中的值复制给rd)

2. SLTI(set less than immediate): 当寄存器rs1中的值小于立即数（俩者都视为有符号数)，将寄存器rd置为1；否则置0。SLTIU: 功能一样，但是把比较的对象视为无符号数。

   1 2 3

   /* 两条指令等效 */ SLTIU rd, rs1, 1(当rs1等于0,rd为1,否则为0) SEQZ rd, rs

3. ANDI, ORI, XORI: 三个逻辑运算符，分别对rs1和立即数执行按位(bitwise)的与，或，异或运算。

   1 2 3

   /* 两条指令等效 */ XORI rd, rs1, -1(-1的补码为全1) NOT rd, rs(将rs各位取反赋值给rd)

   

移位被编码一种特殊的I类型指令格式。

• 被移位的操作数为rs1；移位的位数被编码在立即数域的低五位上。
• 👉移类型被编码在第30位上；
• SLLI(shift left logical)：0被移动到低位
• SRLI: 0被移动到高位
• SRAI: (shift right arithmetic): 原符号位复制到空出的高位

1. LUI(load upper immediate): 用于构建32位常数并使用U格式指令。把U-immediate的值放在目的寄存器的高20位，其它低位用0填充。
2. AUIPC(add upper immediate to pc)：用于构建与pc相关的地址，并使用U格式指令。形成32位的偏移(高20位来自立即数，低12位用0填充)，把这个偏移加到AUIPC指令的地址上，然后把结果放到rd中。（rd = pc-4+im)
   • AUIPC指令支持双指令序列(two-instruction sequences)访问相对PC的任意偏移(for both control-flow transfers and data accesses)
   • 一个AUIPC和JALR中12位偏移的组合能够转换控制给任意32位的PC相对地址(PC-relative address)，而一个ALIPC加上一个常规load和store指令中的12位立即数偏移能供访问任意32位PC相对地址的数据地址(PC-relative data address)
   • 当前PC值可以通过设置立即数为0获得，尽管JAL+4指令也能获得本地PC(JAL下一指令)，它可能在简单微架构中造成流水线崩溃，或者在更复杂的微架构中污染BTB(❓)

Register-Register

RV32I定义了几个R型算术运算。所有的运算都读取rs1,rs2寄存器的值作为源操作数，把结果写回rd寄存器。funct7和funct3域选择合适的运算。

意义同👆。

NOP Instruction

• NOP指令：不会改变任何架构上可见的状态。出来推进PC，增加任何适用的性能计数器。NOP被编码为`ADDI x0, x0, 0
• NOPs可以被用来对齐代码段与重要的微架构地址边界。或者为内联代码修改(inline code modification)流出空间。尽管有许多可能的方法去编码NOP,我们使用了规范的NOP编码来允许微架构优化以及更易读的反汇编输出。其它的NOP编码可以用作指示指令(HINT instruction)
• 选择ADDI作为NOP编码是因为它在跨一系列系统执行时最可能占用最少的资源;除此之外，该指令仅读取一个寄存器。并且，一个ADDI功能单元在超标量设计中更容易可用，因为adds是最常见的运算
• 地址生成单元可以使用相同的硬件够执行ADDI，该硬件被用于base+offset地址计算，而register-register ADD，逻辑运算或移位运算操作需要额外的硬件。

6 Control Transfer

RV32I提供两种控制转义指令：无条件跳转，条件分支

RV32I控制转义指令没有架构上可见的延迟槽(delay slot)

Unconditional Jumps

JAL(jump and link)指令使用J-type格式，J-immediate以两字节的倍数编码一个有符号偏移。(in multiple of 2 bytes；则该偏移要乘以2)。偏移符号扩展，然后加上当前指令的地址形成跳转目标地址(jump target address)。Jumps因此能够访问±1 MiB范围。JAL存储下一条指令的地址(pc+4)到rd；

标准软件调用约定使用x1作为返回地址寄存器，x5作为备用链接寄存器。

JALR(jump and link register)：间接跳转指令：使用I-type，目标地址通过把符号扩展的12比特立即数加到rs1上，然后置结果的最低位为0获得；下一条指令的地址(pc+4)写到寄存器rd。如果结果不需要，可以把x0当作目的寄存器。

如果目标地址没有对齐四字节边界，jar和jarl指令将产生指令地址非对齐异常。

返回地址预测栈(prediction stack)是高性能取值单元的一个常见特点，要求准确检测用于过程调用和返回的指令是有效的。

• 对于RISC-V,关于指令使用的线索通过寄存器号的使用被简单的编码。
• JAL指令应该把返回地址压进返回地址栈(RAS)中，当且仅当rd = x1/x5；
• JALR指令应该push/pop a RAS

Conditional Branches

所有分支指令使用B-type格式。

12比特的立即数用2字节的倍数编码有符号偏移

立即数符号扩展后与当前指令地址相加，可以访问的地址范围：±4 KiB

BEQ:branch equal;  BNE: branch not equal;  BLT: branch less than;  BGE: branch greater than;

• 应该对软件进行优化，使顺序代码路径成为最常见的路径，并将较不经常使用的分支代码路径置于行外。软件还应该假设，至少在第一次遇到分支时，预测向后跳转的分支发生，向前跳转的分支不发生。动态预测器应该快速学习任何可预测的分支行为。
• 不像一些其它的架构，RISC-V中对于非条件分支应该总是使用jump(JAL with rd=x0)指令而不是条件总是满足的有条件分支指令
• RISC-V跳转也是与pc相关的，并且比分支支持更大的偏置范围，而且不会污染条件分支预测表。

7 Load and Store(😳)

RV32I是一个装载和存储架构：只有load和store指令能够访问内存，算术指令只能操作CPU寄存器。

• RV32I提供了32-bit的地址空间，用字节编码。
• EEI定义了地址空间的那部分可以被哪些指令合法访问。(e.g.，一些地址可能只能被读，或仅支持按字访问)
• 目的寄存器为x0的装载指令将抛出异常，即使装载的值被丢弃也会造成其它的副作用。

In RISC-V，endianness is byte-address invariant

• 如果一个字节以某种顺序(at some endianness)存储到内存某个地址处，那么以字节大小从那个地址以任意的顺序(in any endianness)装载的结果是存储的值。

• 小端(little-endian): 多字节存储时把寄存器最低为字节写到内存字节地址的最低为，随后寄存器的其它字节以权重升序写入。（权重越大的字节占据的内存地址越大）

装载和存储指令用于在寄存器和内存中转换数据。

Loads: I-type

Stores: S-type

有效地址：立即数符号扩展加上基址寄存器rs1

目的地址：Ⅰ、for load:从内存取值到rd;Ⅱ、for store：复制rs2的值到内存

8 Memory Ordering

• FENCE：用于排序被其它RISC-V线程，外部设备或者协处理器可见的设备I/O和存储器访问。

• 任何设备输入(I)，设备输出(O)，存储器读取(R),存储器写(W)的组合能够被排序成任何相同的组合。

• 通俗地说，没有其它线程或者外部设备能够在fence之前的指令集进行任何操作之前，观测到在fence后者的指令集合所做的任何操作。就像一个屏障一样，前面的操作只有先完成，后面的指令结果才能被其它处理器观察到。
• memory-mapped I/O设备很典型地被没有cache的loads和store访问，它们使用I和O而不是R和W。
• 指令集扩展也可以描述新的I/O指令，使用fence指令中I和O位进行排序

• fence mode域在ins[31:28]；当fm=0000时排序所有的内存操作。
• 可选的FENCE.TSO指令其fm=1000；predecessor=RW,并且successor=RW。TSO命令它的前面集合中的所有加载操作先于它的后继集合中的所有内存操作；它的前面集合中的所有存储操作(store operation)都要先于它的后继集合中的所有存储操作

9 Call and Breakpoints

SYSTEM instruction：被用于访问需要特权访问的系统功能，使用I-type。

分为两大类：

• 自动读-修改-写(read-modify-write)控制状态寄存器(CSRs)。
• 潜在的特权指令(potentially privileged instructions)

系统指令被定义成运行稍简单的实现总是捕获异常给单一的软件异常处理器(software trap handle)；更加复杂的实现可能需要执行更多条系统指令

这两个指令会向配套执行环境(supporting execution environment)引起一个精确的请求异常(requested trap)。

ECALL

ECALL：向运行环境提出服务请求(service request)

EEl将定义服务请求的参数如何传递，但通常这些都是在整数寄存器中指定的位置

EBREAK

EBREAK：返回控制权给调试器环境(debugging environment)

10 Hint

RV32I为HINT指令保留了大的编码空间，通常是用来和微架构沟通性能提示。HINTs被编码为整数计算指令,其中rd=x0。因此，像nop指令一样，HINTs不会改变架构可见的状态，除了增加pc和任何适用的性能计数器。

1.1 Convention

shall: 用于法定的要求（mandatory requirement）

may: 用于可选的特性（optional feature）

1.2 Syntactic description

BNF描述方法(Backus-Naur Form)：

基本结构为： ::=

• ::=：被定义为的意思
• “ ”: 双引号表示字符串，也就是终结符，不能再被定义。
• 在双引号外的字代表着语法部分；基本类型 ::= 字符串 | 数字 | 布尔,其中字符串、数字、布尔具体是什么，由下面的规则定义（递归）
• <>：尖括号里的内容表示必选内容；
• [...]: 表示可选。
• {...}:表示重复；实例：AB ::= "a" {"b"}表示：AB由一个a加上任意数量（包括0个）个b组成
• (...): 表示分组，用来控制优先级；AX ::= "a" ("m"|"n")表示：AX由一个a加上m或者n组成
• (*...*) : 注释，说明性文本，不表示任何语法。

1. 小写单词，一些包含下划线的：语法目录（syntactic categories）

   ​ module_declaration

2. 粗体：保留字、操作符、标点符号

   ​ module => ;

3. 竖条|分割可选单元。如果它以粗体形式出现，它才表示自己。

   ​ unary_operator ::= + | - | ! | ~ | & | ~& | |(或) | ~|(或非) | ^ | ~^ | ^~（都表示同或)

4. 方括号[…]包含可选项。

   input_declaration ::= input [range] list_of_variables;

5. 花括号{}除非以粗体出现，它才表示自己，否则表示重复。重复从左到右进行，和左递归等效。

   • list_of_param_assignments ::= param_assignment { , param_assignment }

   • list_of_param_assignments ::=
     param_assignment| list_of_param_assignment , param_assignment

6. 任何目录的名字以斜体开头，等效于没有斜体部分的目录名。斜体部分只是为了传达semantic information。

   

7. 正文中当一个term被定义时使用斜体；在例子，文件名，常量特别时0，1，x和z的值时使用constant-width字体（等宽字体）

2、Lexical convention

2.1、Lexical tokens

Verilog HDL source file shall be a stream of lexical tokens. A lexical tokens shall consist of one or more characters.
verilog源文件应该是一连串语法标记，一个语法标记由一个或多个字符组成。

源文件中tokens的位置是随意的，也就是说：除了token分隔符，空格和换行不应该有特殊意义，转义字符除外。

有如下几种语法标记

• White space
• Comment
• Operator
• Number
• String
• Identifier
• Keyword

2.2、White space

white space应该包含：用于空格、制表符、换行符和格式提要的字符。这些字符应该被忽略除了当它们用于分割其他语法标记(tokens)。但是blanks和tabs被认为是有意义的字符在字符串中。

2.3、Comments

• 单行注释 //
• 块注释：/* …. */

2.4、Operators

操作符可以是单个，双个或三个字符的序列，并被用在表达式中。Clause5将讨论表达式中操作符的使用。

单目运算符(Unary operators)：在操作数(operand)的左边

双目运算符(Binary operators)：在两个操作数中间

三木运算符(Triple operator or conditional operator): 有两个操作符字符分割三个操作数（a? x: y)

2.5、Numbers

Constant numbers可以被指定为integer constant或者real constant

2.5.1、Integer constant

有两种表达方式：

1. 简单的十进制数：a sequence of digits of 0 through 9。开头可以加上+或者-（被视为有符号的整数）
2. 指定基码（d，h，o，b）：可选的位宽+'(ASCII 0x27)+基码+digits
   • 位宽：非零无符号十进制数
   • 基码：大小写不敏感；前面可选s指示是否为有符号数（没有s时默认为unsigned integers)
   • '与基码中间不能有空格。⭐
   • digits: 应该紧跟着基码，前面也可以有空格。a-f不区分大小写
   • s不影响指定的位模式，只改变解释方式。❓

• 负数用补码表示
• x代表unknown value；z代表high-impedance value（x应该设为4bit对于h的基码，3bit对于o的基码；z同理）
• 如果无符号数位宽小于指定位宽，那么用0填充；如果无符号数最左边的位是x或z;那么用x或z填充。如果无符号位宽大于指定，那么应该从左边截断到指定位宽。
• 没有指定位宽的数字至少为32位；对于高位是x或者z的没有位宽无符号常数应位扩展到包含该常数的表达式的大小。❓
• ?是z的替代字符。在高阻值不需要注意时，可用？来增加可读性。
• 在十进制常数中，无符号数不能包含任何x,z,?；除非只有一个digit，指示其中每一位都是x或者z。
• _下划线在数字的任何位置都是合法的，除了第一个字符。下划线是没有意义的 ，只是为了分割长的数字提高可读性。

无符号数：

1
2
3
4
5
6
7
8
9
10
11
12

/************* Example 1--Unsized constant numbers *****************/
659    // is a decimal number 
'h 837FF  // is a hexadecimal number 
'o7460   // is an octal number 
4af   // is illegal (hexadecimal format requires 'h)

/************* Example 2--Sized constant numbers *****************/
4'b1001 // is a 4-bit binary number 
5 'D 3 // is a 5-bit decimal number 
3'b01x // is a 3-bit number with the least significant bit unknown 
12'hx // is a 12-bit unknown number 
16'hz // is a 16-bit high-impedance number

有符号数的表示意义：

1
2
3
4
5
6
7

/************* Example 3—Using sign with constant numbers *****************/
8 'd -6 // this is illegal syntax 
-8 'd 6 // this defines the two's complement of 6, held in 8 bits—equivalent to -(8'd 6) 
4 'shf // this denotes the 4-bit number '1111', to be interpreted as a 2's complement number, 
// or '-1'. This is equivalent to -4'h 1 
-4 'sd15 // this is equivalent to -(-4'd 1), or '0001'
16'sd?   // the same as 16'sbz 

自动左填充：

1
2
3
4
5
6
7
8
9
10
11
12

/************* Example 4—Automatic left padding **************************/
reg  [11:0] a, b, c, d;
initial begin
a = 'h x; // yields xxx
b = 'h 3x; // yields 03x
c = 'h z3; // yields zz3
d = 'h 0z3; // yields 0z3
end
reg  [84:0]      e, f, g; 
e = 'h5;    // yields {82{1'b0},3'b101}
f = 'hx;    // yields {85{1'hx}}
g = 'hz;    // yields {85{1'hz}}

使用下划线：

1
2
3
4

/************* Using underscore character in numbers *******************/
27_195_000 
16'b0011_0101_0001_1111 
32 'h 12ab_f001  

2.5.2、Real constants

real constants用IEEE Std 754-1985，双精度浮点数表示

有两种表示方法：

1. 十进制表示：14.72
2. 科学计数法：39e8（表示39乘以10的8次方）

注意：带有小数点的实数至少在小数点两边各有一位。

.12  9.   4.E3   .2e-7 都是不合法的

2.5.3、Convertion

实数向整数转化：四舍五入到最近的整数，而不是截断。

当一个实数被赋值给整数时：进行隐士转化(implicit conversion)

四舍五入规则：away from zero

• -1.5 转化为-2；1.5转化为2

2.6、Strings

字符串是一个字符序列，用(“ “)括起来，包含在一行中。字符串可以用作表达式的操作数；赋值时被当成无符号整数常数，一个8-bit的ASCII值对应一个字符。

2.6.1、String variable declaration

字符串变量是reg类型，宽度=字符个数*8

1
2
3
4
5

/********* "Hello world!"一共12个字符 ********/
reg [8*12:1] stringvar;
initial   begin
  stringvar = "Hello world!";
end

2.6.2、String manipulation

字符串可以用Verilog的操作符进行操纵。被操纵的值是8bit ASCII值序列

1
2
3
4
5
6
7
8
9
10
11
12
13
14

module  string_test;
reg  [8*14:1] stringvar;
initial begin
    stringvar = "Hello world";
    $display ("%s is stored as %h", stringvar,stringvar);
    stringvar = {stringvar,"!!!"};
    $display ("%s is stored as %h", stringvar,stringvar);
end
endmodule


/************** outputs ****************/
Hello world is stored as 00000048656c6c6f20776f726c64
Hello world!!! is stored as 48656c6c6f20776f726c64212121

• 当变量占用空间大于所分配的空间时，值向右调整，最左边用0填充，与处理非字符串的值一样。
• 当占用空间大于分配空间时，字符串还是向右调整，最左边的截断。

2.6.3 Special characters in strings

有些字符只有前面加上escape character它们才能在字符串里面使用

2.7、Identifiers，keywords,and system names

标识符用于给一个对象独一无二的名字，使得它们能呗引用。

简单的标识符：字母，数字，$,  _组成。开头只能是字母或者下划线。（_bus, wan$li)

实现的时候标识符有最大长度，它的限制应该至少为1024个字符。如果一个标识符长度超过这个，系统应该报错。

2.7.1 Escaped identifiers

转义标识符以反斜杠\开始，以white space(space, tab,newline)结束。它们提供了在标识符中包含任何可打印字符的方法（33(!)-126(~)；$21_h$-$7E_h$)。

前导反斜杠和结尾的空白字符都不算标识符的一部分，因此，\cpu3被认为和cpu3一样。

1
2
3
4
5
6

\busa+index
\-clock
\***error-condition***
\net1/\net2
\{a,b}
\a*(b+c)

2.7.2 Keywords

关键字是先前定义好的非转义标识符，它们被用来定义语言结构。关键字前面加上转义字符不被解释为关键字

2.7.3 System tasks and functions❓

美元符号($`)引导一种语言结构：它能开发用户定义的任务和函数；System constructs不是设计原语，而是仿真功能。美元(`$)开头的名字被解释为系统任务或者系统函数。

1
2
3

/*********** for example **********/
$display  ("display a message");
$finish ;

2.7.4 Compiler directives

`（ASICC value 0x60)字符引导用于实现编译器指令的语言结构；，一个描述文件中的编译器指令可以控制多个描述文件中的编译行为。

`identifier 编译器指令结构在以下两种地方定义

• 标准标识符编译器指令
• 由软件实现定义的附加’标识符编译器指令。

任何有效的标识符，包括已经在除此构造之外的上下文中使用的关键字，都可以用作编译器指令名

1
2

/*********** for example **********/
`define  wordsize 8

2.8、Attributes

随着使用Verilog HDL作为源代码的仿真器以外的工具的激增(proliferation); Verilog引入一种机制：用于指定关于HDL源代码中对象、语句和语句组的属性，这些属性可被各种工具(包括模拟器)使用，以控制工具的操作或行为。这些属性被称作attribute. 本小节将介绍: 可以用于指定属性的语法机制。

1
2
3
4
5

attribute_instance ::= (* attr_spec { , attr_spec } *)  
attr_spec ::= 
attr_name [ = constant_expression ]
attr_name ::= 
identifier 

attribute_instance：1、作为声明，模块项目，语句或者端口连接的前缀。2、运算符或在一个表达式中Verilog函数名的后缀

如果没有给属性指派值，那么值默认为1；如果对相同的language element定义多个相同的属性名字，那么最后一个属性值将被使用；工具可以在这种情况下给个warning。

nesting of attribute instances 不被允许；用包含属性实例的常量表达式(constant expression that contains an attribute instance)去给属性赋值是不合法的。

2.8.1 Examples

• 范例1：给case语句贴上属性

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

  (* full_case, parallel_case *) case (foo) <rest_of_case_statement> or (* full_case=1 *) (* parallel_case=1 *) // Multiple attribute instances also OK case (foo) <rest_of_case_statement> or (* full_case, // no value assigned；默认为1 parallel_case=1 *) case (foo) <rest_of_case_statement>

• 范例2：给模块定义加属性

  1 2	(* optimize_power *) module mod1 (<port_list>);

• 范例3：给模块实例加属性

  1 2	(* optimize_power=0 *) mod1 synth1 (<port_list>);

• 范例4：给reg声明加属性

  1 2 3 4

  (* fsm_state *) reg [7:0] state1; (* fsm_state=1 *) reg [3:0] state2, state3; reg [3:0] reg1; // this reg does NOT have fsm_state set (* fsm_state=0 *) reg [3:0] reg2; // nor does this one

• 范例5：给操作符加属性

  1 2	a = b ? (* no_glitch *) c : d; a = b + (* mode = "cla" *) c;

  2.8.2 Syntax(省略)

指令集并行(instruction-level parallelism)有两种方式

Ⅰ、Pipeline——详见数据通路(3)；流水线越深，并行度越高。

Ⅱ、多发射（multiple issue）: 本节所要讲述的重点。通过复制计算机内部部件的数量，使得每个流水级可以启动多条指令

• 多发射可以使指令执行速度超过时钟的速度，即CPI小于1。
• 实现多发射有两种办法：1、static multiple issue；2、dynamic multiple issue。

多发射流水线必须处理以下两个问题：

1. 打包指令到发射槽(issue slots)：在大多数静态多发射实现上：在一个时钟周期发射多少条指令，哪些指令被发射这个过程至少很大一部分由编译器来完成。而在动态发射处理器中，这个问题一般由处理器在运行时来处理。（尽管编译器已经优化了指令顺序来尽可能多发射）
2. 处理数据和控制冒险：在静态发射处理器中，编译器解决大部分或者所有的可能冒险。与此相反的，动态发射处理器用硬件技术在运行时至少消除某些类别的冒险。

尽管，我们把它们描述成不同的方法，但事实上，一个方法经常借助另外一个方法的技术。

Speculation(推测)

speculation: An approach whereby the compiler or processor guesses the outcome of an instruction to remove it as a dependence in executing other instructions
提前给出结果(猜测)来避免后面的指令对正在运行指令的依赖

以下是几种猜测的情形：

• 我们猜测分支的结果，那样分支后面的指令可以提早执行。
• 我们猜测存字和取字指令访问的不是同一个地址，那样我们在执行存字指令前去执行取字指令。

但是，猜测可能出现错误❌。所以：任何推测技术都必须包含一种机制：1、检查推测是否正确；2、回滚由于推测提前执行的指令的影响。

1. 推测错误时恢复机制：

   • for compile: 插入额外的指令检查推测的正确性✔并提供一个fix-up例程供推测错误时使用。
   • for processor: 用buffer缓存推测结果直到推测的结果得到确认。如果推测正确，把缓存的能容写到相应的寄存器中，指令完成。如果推测不正确，硬件冲刷掉buffer，重新执行正确的指令序列。

2. 推测可能引入另外的问题：对某些指令的推测会导致原本不存在的异常发生。比如，推测执行一条装载指令，在推测错误的情况下，该指令所使用的地址是非法的。

Static multiple-issue

Static multiple-issue processers all use the compiler to assist with packaging instructions and handling hazards.

issue packet(发射包)：在一个时钟周期内可以发射的指令集合，可以用一条完成多种操作的长指令来类比

Very Long Instruction Word(超长指令字)：一种指令集架构，能够发射多条操作，这些操作在单个指令中被定义为独立的，并且一般都有独立的操作码域。

• 静态多发射处理器有两种：

  1. 编译器避免所有冒险；
  2. 硬件检测数据冒险，并在两个发射包间产生阻塞，而编译器只负责避免一个指令包间的依赖。

• 为了并行发射ALU和数据传输操作，需要有额外的硬件：

  1. 寄存器堆要有额外的端口供连个操作读取操作数；
  2. 要有额外的ALU来同时执行EX阶段。

• 多发射带来的问题：由于额外的指令重叠，冒险的可能性加倍。

  1. 装载指令有一个时钟周期的使用延迟（use latency)；这意味着下一个发射包中所有指令都不能使用装载的结果。
  2. 原本没有使用延迟的ALU指令，其结果不能被在同一个发射包的其他指令使用。

• 循环展开(loop unrolling)：一种从访问数组的循环程序中获得更多性能的技术。其中循环体会被复制多份并且在不同循环体中的指令会调度在一起。

1
2
3
4
5
6

/***************** 例程：把一段数组中的数全部加上一个数(x21)  ********************/
Loop:  ld  x31, 0(x20)  // x31=array element
       add  x31, x31, x21   // add scalar in x21
       sd  x31, 0(x20) // store result
       addi  x20, x20, -8   // decrement pointer
       blt  x22, x20, Loop  // compare to loop limit,branch if x20 > x22

不进行循环展开的静态多发射调度：

循环展开结果：

• 在循环展开过程中，编译器引入了几个临时编译器（x28、x29、x30）。这个过程叫做寄存器重命名: 目的是消除一些虚假依赖。
• 如果我们只使用x31寄存器：我们将在sd x31,8(x20)后面重复ld x31,0(x20), add x31, x31, x21。但是这些序列尽管都使用x31，它们实际上是不相关的。
• antidependence or name dependence(反相关或名字相关)：一组指令集和下一组指令集之间no data value flow，仅仅是因为重用寄存器名引起的相关。

Dynamic multiple-issue

Dynamic multiple-issue processors are also known as superscalar processors, or simply superscalars

Basic concept

最简单的超标量处理器：指令按顺序发射，处理器决定每个周期发射0条，1条或多条指令。

显然为了获得好的性能，处理器仍然需要编译器帮忙编排指令顺序来减少依赖。

简单超标量处理器与VLIW处理器(静态发射)的区别：

• for superscalar:：1、不管是否经过编译器编排指令顺序，都由硬件来保证执行的正确性✔。2、编译过的代码将始终正确的运行，无论发射速率还是流水线架构。
• for VLIW：不像👆那样，当移植到不同的处理器模型往往需要重新编译。在其他的静态发射处理器中，代码能够在不同的处理器实现上正确运行，但是效率很差也需要重新编译。

许多超标量处理器扩展了基本的动态发射策略，将dynamic pipeline scheduling(动态流水线调度)包含进来。

1
2
3
4
5

/*************** 一个简单的例子 **************/
ld  x31, 0(x21)
add  x1,  x31, x2
sub  x23, x23, x3
andi  x5,  x23, 20

说明：即使sub指令准备好执行，它也必须等待ld和add指令先结束才行。如果内存很慢，sub指令可能会等待多个周期（比如cache没有命中）

dynamic pipeline scheduling

Dynamic pipeline scheduling chooses which instructions to execute next, possibly reordering them to avoid stalls.
动态调度可以运行时动态调整指令顺序

流水线被分为三个主要部分：

• an instruction fetch and issue unit（取指发射单元)
• multiple functional units（多种功能单元）
• commit unit(提交单元)

1. 每个功能单元有个buffer, 称为保留站（reservation station)，其中保存着操作数和操作(opcode ❓)。
2. 功能单元运算完成的结果传送给1、commit unit；2、旁路给所需的保留站。
3. 提交单元也有buffer，称为reorder buffer(重排序缓冲区)：缓存结果直到确定是安全时才写入register file或者memory。

保留站缓存操作数➕提交单元缓存结果＝＝》寄存器重命名

• 发射指令时，它被复制到对应功能单元的保留站上，如果它的操作数在寄存器堆或者提交单元缓冲区中有，那么操作数立马复制到保留站。如果指令已经发射，那么对应操作数的副本不再需要，可以重写覆盖。
• 如果一个操作数不在register file or reorder buffer，他必须等待某个功能单元的结果。硬件帮助追踪所需的功能单元，当单元计算出结果直接复制到保留站而旁路掉寄存器堆。

out-of-order execution(乱序执行)：处理器在不违背原有数据流顺序的前提下以某种顺序执行各条指令，但是执行指令的顺序可以与取指不同。

in-order commit(顺序提交)：流水线执行的结果以取指顺序写回程序员可见的寄存器的一种提交方式。（当异常发生时，处理器可以找到最后执行的那条指令，而只有这条导致异常的指令之前的指令才能对寄存器状态进行改变。

推测和动态调度经常结合在一起：

• 通过对分支的预测，动态调度可以在推测方向上进行取指和执行。由于指令是顺序提交，我们可以在分支指令及所有推测执行的指令提交前知道推测是否准确。
• 通过对装载指令目的地址的预测，对存取指令进行重排序和利用提交单元避免错误的推测。

流水线就像工厂的工人一样，每个工人只做一道工序（每个硬件只做一个功能)，同一时间几道工序同时在做(同一时间多条指令同时执行，每条指令在不同的阶段)，最后一道工序做完即完成了一件产品(所以吞吐量非常大)。

RISC-V经典流水线可以分为五步

• Fetch instruction from memory（IF)
• Read register and decode the instruction(ID)
• Execute the operation or calculate an address(EX)
• Access an operand in data memory (MEM) [if necessary]
• Write the result into a register(WB) [if necessary]

面向流水线的指令集设计

• RISC-V 指令等长，这一限制简化了第一级取指与第二级译码。

  【x86指令长度不等，从1字节到15字节不等。最近x86体系结构：先转化为简单的操作】

• RISC-V只有几种指令格式，每一种指令源和目的寄存器字段位置不变。

  【使得第二级在确定指令类型的同时开始读寄存器堆】

• RISC-V的memory operands仅仅出现在存取指令中(常规ALU指令的操作数直接在第二级寄存器堆读出)。意味着我们可以在执行阶段计算内存地址，然后在下一个阶段访存。

  【如果像x86那样可以操作在内存中的操作数，那么第三、四级将扩展为address stage，memory stage，execute stage】

流水线控制

2、Pipeline Hazards

There are situation in pipelining when the next instruction cannot execute in the following clock cycle. These events are called hazards.

1、Structural Hazard

When a planned instruction cannot execute in the proper clock cycle because the hardware does not support the combination of instructions that are set to execute

这也是为什么我们我们的IF和MEM分开（指令寄存器和数据寄存器）

2、Data Hazard

When a planned instruction cannot execute in the proper clock cycle because data that are needed to execute the instruction are not yet available

三种经典解决办法

• Reorder code(重新安排代码)
• stall the pipeline(阻塞一个或几个周期)
• bypass or forwarding(旁路或者前推上一条指令运算的结果)

①Reorder code

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

//code segment in C
a = b + e;
c = b + f;

//generated RISC-V code for above segment
ld x1, 0(x31)// Load b   1
ld x2, 8(x31)// Load e2
add x3, x1, x2// b + e3
sd x3, 24(x31)// Store a4
ld x4, 16(x31)// Load f5
add x5, x1, x4// b + f6
sd x5, 32(x31)// Store c7

/************** 说明 *****************
1、通过旁路可以去除3对1的依赖(load 指令最少需要两个周期，ALU指令在旁路技术下对下一条指令不会构成数据冒险）
2、通过旁路也可解决sd指令对上一条add指令的依赖
3、需要解决的: 3V2和6V5         */

//************* 解决办法 ***************
把第5条指令提到第二条指令和第三条中间。

②Bypassing

• and指令需要x2，而x2只有等到第一条指令写回才有效(即第五个周期前半段)
• 同理or指令
• ❓假设: 写寄存器操作发生时钟周期的前半段而读寄存器操作发生在时钟周期后半段

旁路的核心：前一条指令计算的结果不用等到第五周期写回寄存器堆而提前旁路到其后指令的ALU操作数输入上。

• EX冒险（EX/MEM流水线寄存器有需要的值）

  1 2 3 4 5 6 7

  if (EX/MEM.RegWrite and (EX/MEM.RegisterRd ≠ 0) and (EX/MEM.RegisterRd = ID/EX.RegisterRs1)) ForwardA = 10 if (EX/MEM.RegWrite and (EX/MEM.RegisterRd ≠ 0) and (EX/MEM.RegisterRd = ID/EX.RegisterRs2)) ForwardB = 10

• MEM hazard

  1 2 3 4 5 6 7 8 9 10 11 12

  if (MEM/WB.RegWrite and (MEM/WB.RegisterRd ≠ 0) and not(EX/MEM.RegWrite and (EX/MEM.RegisterRd ≠ 0) and (EX/MEM.RegisterRd = ID/EX.RegisterRs1)) // 先判断不是EX冒险，不然应该是旁路上一条指令EX/MEM结果旁路上上条MEM/WB and (MEM/WB.RegisterRd = ID/EX.RegisterRs1)) ForwardA = 01 if (MEM/WB.RegWrite and (MEM/WB.RegisterRd ≠ 0) and not(EX/MEM.RegWrite and (EX/MEM.RegisterRd ≠ 0) and (EX/MEM.RegisterRd = ID/EX.RegisterRs2)) and (MEM/WB.RegisterRd = ID/EX.RegisterRs2)) ForwardB = 01

• 旁路单元产生控制信号选着ALU的输入operand。

③Stalls

需要阻塞的情形：当一条指令试图读取一个由前一条装载指令读入的寄存器时，就无法使用旁路解决冒险(因为lw指令需要在第四阶段才能产生结果)

1. 冒险检测单元

   1 2 3 4

   if (ID/EX.MemRead and ((ID/EX.RegisterRd = IF/ID.RegisterRs1) or (ID/EX.RegisterRd = IF/ID.RegisterRs2))) stall the pipeline

2. 检测单元工作在ID阶段。

3. 阻塞后面指令的方法：保持PC寄存器和IF/ID流水线寄存器不变。

4. 插入一条空指令（nop)：一种不进行任何操作或不改变任何状态的指令。

   实现方法：控制信号全部置为0，这些控制信号在每个时钟周期都向前传递，但不会产生不良影响，因为控制为0，那么所有寄存器和存储器都不进行写操作。

3、Control Hazard

An instruction must be fetched at every clock cycle to sustain the pipeline, yet in our design the decision about whether to branch doesn't occur until the MEM pipeline stage.
(后面的优化🙆‍看到在ID级就可以确定分支)

①Branch

1. 假定分支不发生（如果发生预取和译码的指令要丢弃）

2. 缩短分支延迟（提早确定分支，减少flush的指令数）

   • 计算分支目标地址（IF/ID流水线寄存器已经有了PC和立即数字段的值）

   • 判断分支条件：需要额外的旁路和冒险检测硬件。【因为分支条件的判断可能依赖于还在流水线中的结果】

     两个难点：

     Ⅰ、前面的ALU旁路单元在EX级，所以这里需要一个新的旁路单元工作在ID级。还需要一个equality test logic（对两个寄存器的值按位异或接着或操作）

     Ⅱ、可能数据在ID级旁路不过来。上一条是ALU指令，那么只能stall a cycle；如果是lw指令，那么必须stall two cycles。

     Ⅲ、控制信号新增一个IF.flush信号，把预取的那条指令变成nop指令。

3. 动态分支预测(缓存之前运行分支的信息进行判断)
   fetching new instructions from the same places as the last time.)

   • 分支预测缓存(branch prediction buffer)也称为分支历史记录表(branch history table):使用分支指令地址地位索引的一小块存储区。
   • 这类缓存我们实际上不知道预测是否正确，而且它还可能由其他具有相同地址地位的分支设置。
   • 预测错误❌时，错误的预取指令删除，预测位取反，回到原来的位置（❓得有缓存），继续按照正确的方向取指并执行。
   • 分支预测缓存可以用很小，用指令地址访问的special buffer in IF pipe stage。如果预测分支，那么从分支target取指令。
   • 为了改善非常有规律的分支的预测正确率（比如循环，9次分支只有最后一次循环退出不分支）；可以使用两位的预测机制。

   

   • 相关预测器（correlation predictors)：不仅使用local branch的信息，还综合global behavior of recently executed branches 。典型的相关预测器为每个分支提供两个两位的预测器，根据上一次分支是否执行选择其中一个预测器，因此全局分支行为可以看成adding additional index bits for the prediction lookup.
   • 竞争预测器(tournament branch predictor)：为每个分支使用多个预测器，并记录哪个预测器预测结果最好。典型的竞争预测器：对每个分支索引包含两个预测结果，一个基于本地信息，一个基于全局分支行为。一个选择器选择哪个作为预测结果。
   • 条件移动指令(conditional move instruction)：不同于分支指令改变PC值，条件移动指令将根据条件改变move指令的目的寄存器。在ARMv8指令集架构中：CSEL X8, X11,X4,NE 如果条件码不为零，复制x11到x8；否则复制X4到X8;

②Exception

Control is the most challenging aspect of processor design: it is both the hardest part to get right and toughest part to make fast
然而控制中最难的就是实现异常或中断——除分支外改变正常指令执行流

当异常发生时，处理器必须做的基本事情是：

• 在SEPC(supervisor exception cause register)保存出错指令的地址
• 把控制权交给操作系统的特定地址处

对于处理异常的OS,它必须知道异常的原因：

• 设置一个原因寄存器（Supervisor Exception Cause Register or SCAUSE):其中有个域指示异常的原因

• 使用向量中断(vectored interrupts), 控制权被转移到的地址是由异常原因决定，该地址可能被添加到指向向量中断内存范围的base register中。例如，我们可以使用下面的异常中断向量地址来表示异常种类。

  

异常在流水线中的实现(使用自前相同的机制，不过这次由异常重置控制信号)

• IF级指令的清除用之前的IF.flush信号
• 新增ID.Flush信号和之前的冒险检测单元产生的stall信号进行或运算，然后加在自前的多选器上，实现ID级指令清除
• 新增一个EX.Flush信号清除EX级的指令
• 为了从异常处理程序的地址取指，只要简单家一个额外的输入到PC的多选器。

MIPS ALU在4位控制信号上定义了6种有效的输入组合

• 存储器访问指令：add
• R型指令：根据指令低6位的funct字段¹ ，ALU执行5种操作中的一种(nor暂时没用)
• branch指令：sub(两个操作数相减判断是否为零)

• 多级译码：输入：6位funct字段和2位ALUOP字段————>输出：4位ALU control lines

• 真值表——优化后转换为门电路（坑待定）

2、主控制单元

• 指令格式

• R型指令opcode为0；lw为35；sw为43 ; branch为4⃣

• 控制信号真值表

  

• op[5:0]取至Instruction[31:26]

• RegDst: R为1表示目的寄存器为rd; lw为rs; sw和branch不用写回寄存器堆所以没有目的寄存器。
• ALUSrc: R和branch为0表示ALU第二个操作数来自rt; lw和sw表示第二个操作数来自低16位的扩展。
• MemtoReg: sw和branch为x表示不用写回。R为0表示ALU计算结果写回；lw表示数据寄存器取出来的数写回
• Regwirte: R和lw要写回所以为1。
• MenRead: 只要lw要读所以只有lw为1
• MemWrite: 只有sw要写
• Branch: 只有branch才触发
• ALUOP: R为10；存储为00；branch为01

• 跳转实现（即改变PC的值）

  其OPcode为2.低26位都是offset_address。