📚 使用须知
- 本博客内容仅供学习参考
- 建议理解思路后独立实现
- 欢迎交流讨论
32位常数的装入
int f() { return 0x123; /* 291 */ }
int g() { return -1; }
int h() { return 0x1234; /* 4660 */ }
int i() { return 0xbb8; /* 3000 */ }
rv32gcc -O2 -c a.c
rvobjdump -M no-aliases -d a.o
lui r,(imm[31:12]+imm[11]) # 若结果为0, 可省略
addi r,zero,imm[11:0]
理解lui中的imm[11]: 一大步(lui) + 一小步(addi)
________________________________________________| | | | | |-1 | 291 3000 | 46600 4096
根据addi的语义,imm[11:0]需要符号扩展
相当于对lui结果进行±2048范围内的调整(可仔细推敲边界情况)
lui需要先装入一个距离imm不超过±2048范围的数
如果imm[11:0]为负, 则lui需先右移4096, 再让addi左移
64位常数在RV64中的装入
long long j() { return 0x1234567800000000; }
long long k() { return 0x1234567887654321; }
rv64gcc -O2 -S a.c
多一条移位指令slli
如果再复杂一点, gcc干脆把常数放到只读数据段, 用ld读内存
用访问数据的延迟换取更短的指令序列
指令太多并不好: 乱序执行的高性能CPU中, 取指令的代价大于取数据
在流水线中, 指令是数据的上游
若从内存取数据, 只需让取数逻辑等待, 可先执行其他无关指令
若从内存取指令, 则整条流水线都要等待
伪指令的定义可参考《RISC-V汇编语言编程手册》
long long j() { return 0x1234567800000000; }
long long k() { return 0x1234567887654321; }
rv32gcc -O2 -S a.c
用两个32位寄存器联合存放一个64位数据
在这个版本中, clang生成的代码比gcc更好一些 😂
clang --target=riscv32 -O2 -S a.c
变量的大小和对齐
RISC-V的两套整数ABI
I = Integer, L = Long, P = Pointer
ILP32 ABI (RV32)
| 大小 | 对齐 | |
|---|---|---|
| bool/_Bool | 1 | 1 |
| char | 1 | 1 |
| short | 2 | 2 |
| int | 4 | 4 |
| long | 4 | 4 |
| long long | 8 | 8 |
| void * | 4 | 4 |
| float | 4 | 4 |
| double | 8 | 8 |
LP64 ABI (RV64)
| 大小 | 对齐 | |
|---|---|---|
| bool/_Bool | 1 | 1 |
| char | 1 | 1 |
| short | 2 | 2 |
| int | 4 | 4 |
| long | 8 | 8 |
| long long | 8 | 8 |
| void * | 8 | 8 |
| float | 4 | 4 |
| double | 8 | 8 |
变量的分配
{v1,v2,…}→{r1,r2,…,M}
在实际的电路中
R访问速度较快(当前周期可读出), 但容量有限(RISC-V中只有32个)
M访问速度较慢(需要上百个周期读出), 但容量几乎无限(现代内存条8~32GB)
DDR颗粒中的存储单元由一个晶体管+一个电容组成
电容需要充放电, 延迟普遍比晶体管大, 故通常M的访问速度较慢
C程序中的变量远多于寄存器, 该如何分配?
直观的分配策略: 将常用的变量分配在R, 将不常用的变量分配在M，但编译器很难分析哪些变量更常用
实际的分配策略: 所有变量先分配在M, 需要访问时读入R
程序的内存布局
与变量相关的三个内存区域: 静态数据区(data), 堆区(heap), 栈区(stack)
静态 = 不动态增长和变化, 编译时确定
四种需要分配的C变量
全局变量 -> data区
静态局部变量 -> data区
非静态局部变量 -> stack区
动态变量 -> heap区
+----------+| |+----------+| stack |+----------+| | || v || || ^ || | |+----------+| heap |+----------+| data |+----------+| text |+----------+| |
0 +----------+
#include <stdio.h>
#include <stdlib.h>
int g;
void f(int n) {static int sl;int l, *h = malloc(4);printf("n = %2d, &g = %p, &sl = %p, &l = %p, h = %p\n", n, &g, &sl, &l, h);if (n < 5) f(n + 1);
}
int main() { f(1); printf("===\n"); f(1); return 0; }
变量的访问
#define def(type, name) \volatile type name ## _a; \volatile type name ## _b; \void f_##name () { name ## _a = name ## _b; }def(_Bool, _Bool)
def(char, char)
def(signed char, signed_char)
def(short, short)
def(unsigned short, unsigned_short)
def(int, int)
def(unsigned int, unsigned_int)
def(long, long)
def(long long, long_long)
def(void *, void_)
def(float, float)
def(double, double)
rv32gcc -O2 -S a.c
rv64gcc -O2 -S a.c
一个例外: unsigned int在RV64中使用lw而不是lwu
具体可参考RISC-V指令集手册和RISC-V ABI手册
变量的访问(2)
ILP32 ABI (RV32)
| 大小 | 指令 | |
|---|---|---|
| bool/_Bool | 1 | lbu/sb |
| char | 1 | lbu/sb |
| signed char | 1 | lb/sb |
| short | 2 | lh/sh |
| unsigned short | 2 | lhu/sh |
| int | 4 | lw/sw |
| unsigned int | 4 | lw/sw |
| long | 4 | lw/sw |
| long long | 8 | lw+lw/sw+sw |
| void * | 4 | lw/sw |
| float | 4 | flw/fsw |
| double | 8 | fld/fsd |
LP64 ABI (RV64)
| 大小 | 指令 | |
|---|---|---|
| bool/_Bool | 1 | lbu/sb |
| char | 1 | lbu/sb |
| signed char | 1 | lb/sb |
| short | 2 | lh/sh |
| unsigned short | 2 | lhu/sh |
| int | 4 | lw/sw |
| unsigned int | 4 | lw/sw |
| long | 8 | ld/sd |
| long long | 8 | ld/sd |
| void * | 8 | ld/sd |
| float | 4 | flw/fsw |
| double | 8 | fld/fsd |
变量分配不对齐会降低访问效率
不对齐即addr(n) % align(n) != 0, 如int变量分配在地址0x13
硬件支持不对齐访存: 电路更复杂, 且需要两个周期以上
软件支持不对齐访存: 抛异常, 效率很低
在x86上实测不对齐访存的性能
#include <stdlib.h>
#define LOOP 2000000
#define SIZE 10000
char buf[SIZE + 64] __attribute((aligned(64))); // 64 = 缓存块的大小(字节)
int main(int argc, char *argv[]) {int offset = atoi(argv[1]);for (int n = LOOP; n != 0; n --) {for (char *p = buf + offset; p < buf + SIZE; p += 64) { *(long *)p = 1; }}return 0;
}
gcc -O2 a.c && for i in `seq 1 64`; do TIME="$i: %E" /usr/bin/time ./a.out $i; done
在x86上, 当不对齐的数据跨越64字节边界时, 可观察到约2x的性能下降
运算和指令
| C运算符 | RISC-V指令 |
|---|---|
| +, -, *, /, % | add, sub, mul, div, rem |
| = | mv, 访存指令 |
| &, |, ^ | and, or, xor |
| ~ | xori r, r, -1 |
| <<, >> | sll, srl, sra |
| ! | sltiu r, r, 1 |
| <, > | slt |
long f1(long a, long b) { return a + b; }
long f2(long a, long b) { return a - b; }
long f3(long a, long b) { return a * b; }
long f4(long a, long b) { return a / b; }
// ...
通过-O1编译成汇编文件, 即可了解二者的联系
编译优化 - 尽可能在寄存器中进行运算
int sum = 0;
void f() {int i;for (i = 1; i <= 100; i ++) {sum += i;}
}
-O0 - 每次计算前先从内存读出变量, 每次计算后马上写回内存
-O1 - 开始计算前从内存读出变量, 计算过程在寄存器中进行, 计算全部结束后再写回内存
-O2 - 编译器直接把结果算好了
RV32进行64位加法
long long f1(long long a, long long b) { return a + b; }
rv32gcc -O2 -S a.c
(a1, a0) <= (a1, a0) + (a3, a2)mva1 a0 ===> a5a3 a2 |vcarry <--- sltu+ ^--------- |a1 a0 -----+
RV64进行128位加法, 过程类似
__int128 f1(__int128 a, __int128 b) { return a + b; }
有符号数和无符号数
#include <stdint.h>int32_t add1( int32_t a, int32_t b) { return a + b; }
uint32_t add2(uint32_t a, uint32_t b) { return a + b; }int32_t cmp1( int32_t a, int32_t b) { return a < b; }int32_t cmp2(uint32_t a, uint32_t b) { return a < b; }int32_t shr1( int32_t a, int32_t b) { return a >> b; }
uint32_t shr2(uint32_t a, int32_t b) { return a >> b; }int64_t zext1( int32_t a) { return a; }
uint64_t zext2(uint32_t a) { return a; }
add1和add2的代码完全一样
结论: 在RISC-V硬件看来, 有符号加法和无符号加法的行为完全一致
可以使用同一个加法器模块进行计算
比较 - slt/sltu
右移 - sra/srl
扩展到64位 - 符号扩展/零扩展
乘, 除, 取余均有两种符号的指令
