CSAPP Lab-4 Architecture Lab

本次实验是有关书上第四章设计的 Y86-64 处理器的，实验分为三个部分，分别是编写几个简单的 Y86-64 程序、使用一条新指令扩展 SEQ 模拟器以及优化 Y86-64 的基准测试程序和处理器设计。

实验准备

需要简单复习一下 Y86-64 的指令集架构以及处理器架构呢。

指令集架构

指令集：

./20230904-csapp-archlab/image-20230904203030200

指令功能码：

./20230904-csapp-archlab/image-20230904203218950

程序员可见状态：

./20230904-csapp-archlab/image-20230904203138458

以及，书上这一章似乎没有提到，但是根据上一章的内容，我们一般将 %rdi, %rsi, %rdx, %rcx 用作参数的传递，而 %rbx, %rbp, %r12~%r15 是被调用者保存寄存器，被调用的函数有义务在使用之前保存寄存器的内容。

处理器架构

./20230904-csapp-archlab/image-20230904204101080

./20230904-csapp-archlab/image-20230904204258146

这两张图是 PIPE 的硬件结构和流水线控制逻辑，当然并不完整。在我们需要的时候，我们会补充相应的示意图。

Y86-64 的程序结构

书本给我们提供了一个典型的 Y86-64 汇编程序，这将是我们完成 Part A 的参考。

./20230904-csapp-archlab/image-20230904204852913

其中，程序从 0x0 开始执行，首先将栈地址（在程序的末尾标识出来）放入 %rsp 寄存器，然后调用 main 函数，main 函数运行结束后终止程序。下面是预定义的全局数据，然后就是各个函数过程。

Part A

Part A 需要我们写三个 Y86-64 的程序，每个程序分别完成了三个函数，并发起对这些函数的调用。

这个 Part 不是很难，只需要根据汇编程序的书写语法、分支循环的转化方法以及 Y86-64 指令集的一些约束来写就可以了。

sum.ys: Iteratively sum linked list elements

要被我们转译的函数如下：

 /* sum_list - Sum the elements of a linked list */
long sum_list(list_ptr ls)
{
    long val = 0;
    while (ls) {
		val += ls->val;
		ls = ls->next;
    }
    return val;
}

这个程序是对一个链表的迭代求和。实验给我们提供了一组示例数据：

 # Sample linked list
.align 8
ele1:
    .quad 0x00a
    .quad ele2
ele2:
    .quad 0x0b0
    .quad ele3
ele3:
    .quad 0xc00
    .quad 0

这个部分很简单，我的程序是：

 # sum_list - Sum the elements of a linked list
# by Irilsy
 
# Execution begins at address 0
    .pos 0
    irmovq stack, %rsp  # Set up stack pointer
    call main           # Execute main program
    halt                # Terminate program
 
# Sample linked list
.align 8
ele1:
    .quad 0x00a
    .quad ele2
ele2:
    .quad 0x0b0
    .quad ele3
ele3:
    .quad 0xc00
    .quad 0
main:
    irmovq ele1, %rdi
    call sum_list
    ret
sum_list:
    xorq %rax, %rax
    jmp test
loop:
    mrmovq (%rdi), %rsi
    addq %rsi, %rax
    mrmovq 8(%rdi), %rdi
test:
    andq %rdi, %rdi
    jne loop
    ret
 
# Stack starts here and grows to lower addresses
    .pos 0x200
stack:

在 main 函数中，我们示例数据的地址放入 %rdi，然后调用 sum_list 函数。

在 sum_list 函数中，我们用 %rax 代表 val，第一句指令将 val 清空。while 循环我们使用跳转到中间的方法实现，直接 jmp 到条件判断的位置。在循环内部，我们仍旧使用 %rdi 代表 ls 指针，(%rdi) 就是 ls->val，8(%rdi) 就是 ls->next。循环体的三句话按照含义模拟即可。在条件判断的地方，我们使用 andq 作为与 $0$ 的比较。

./20230904-csapp-archlab/image-20230904210917180

rsum.ys: Recursively sum linked list elements

这次要被我们转写的函数是：

 /* rsum_list - Recursive version of sum_list */
long rsum_list(list_ptr ls)
{
    if (!ls)
    return 0;
    else {
        long val = ls->val;
        long rest = rsum_list(ls->next);
    	return val + rest;
    }
}

示例数据与前一个程序相同。这个版本是递归版的 sum_list，使用递归的方法对一个链表求和。

也很容易，按照含义模拟即可：

 # rsum_list - Sum the elements of a linked list
# by Irilsy
 
# Execution begins at address 0
    .pos 0
    irmovq stack, %rsp  # Set up stack pointer
    call main           # Execute main program
    halt                # Terminate program
 
# Sample linked list
.align 8
ele1:
    .quad 0x00a
    .quad ele2
ele2:
    .quad 0x0b0
    .quad ele3
ele3:
    .quad 0xc00
    .quad 0
main:
    irmovq ele1, %rdi
    call rsum_list
    ret
rsum_list:
    xorq %rax, %rax
    andq %rdi, %rdi
    je end
    pushq %rbx
    mrmovq (%rdi), %rbx
    mrmovq 8(%rdi), %rdi
    call rsum_list
    addq %rbx, %rax
    popq %rbx
end:
    ret
 
# Stack starts here and grows to lower addresses
    .pos 0x200
stack:

与 sum.ys 基本一致，区别在于 rsum_list 函数的写法。仍然使用 %rax 代表 val。在函数的开头就把 %rax 清零，方便下一句的判断中如果 ls 指针为空可以直接返回。

然后，我们从内存中取出 (%rdi)（ls->val），但是需要递归调用，这个时候有两种处理方法，第一种是不把这个数据留在寄存器中，而是存储在内存里，在递归调用结束后再取出。还有一种是使用被调用者保存的寄存器 %rbx，在使用之前将 %rbx 的内容保存进栈中，然后将我们取出的数据放进 %rbx，在调用前不用特别保存，因为任何函数在使用这个寄存器前都会保存的。我是用的是第二种方法。

在调用结束后，我们将返回值和 %rbx 中的 ls->val 加起来返回即可。

./20230904-csapp-archlab/image-20230904211009323

copy.ys: Copy a source block to a destination block

这次要我们转译的函数是下面这个：

 /* copy_block - Copy src to dest and return xor checksum of src */
long copy_block(long *src, long *dest, long len)
{
    long result = 0;
    while (len > 0) {
        long val = *src++;
        *dest++ = val;
        result ^= val;
        len--;
    }
    return result;
}

这个函数的功能是将从 src 开始的 len 个 long 型数据复制到 dest 处，并返回它们的异或和。

实验提供的示例数据是：

 # Source block
src:
    .quad 0x00a
    .quad 0x0b0
    .quad 0xc00
 
# Destination block
dest:
    .quad 0x111
    .quad 0x222
    .quad 0x333

我的写法如下：

 # copy_block - Sum the elements of a linked list
# by Irilsy
 
# Execution begins at address 0
    .pos 0
    irmovq stack, %rsp  # Set up stack pointer
    call main           # Execute main program
    halt                # Terminate program
.align 8
# Source block
src:
    .quad 0x00a
    .quad 0x0b0
    .quad 0xc00
 
# Destination block
dest:
    .quad 0x111
    .quad 0x222
    .quad 0x333
main:
    irmovq src, %rdi
    irmovq dest, %rsi
    irmovq $3, %rdx
    call copy_block
    ret
copy_block:
    xorq %rax, %rax
    irmovq $8, %r8
    irmovq $-1, %r9
    jmp test
loop:
    mrmovq (%rdi), %rcx
    addq %r8, %rdi
    rmmovq %rcx, (%rsi)
    addq %r8, %rsi
    xorq %rcx, %rax
    addq %r9, %rdx
test:
    andq %rdx, %rdx
    jg loop
 
# Stack starts here and grows to lower addresses
    .pos 0x200
stack:

首先是 main 函数中，src, dest, $3 分别作为 %rdi, %rsi, %rdx 传入 copy_block 函数，也就是前三个参数。

copy_block 函数中，我们使用 %rax 代表 result，val 中间变量存储在 %rcx 中。具体的代码按照含义模拟即可。需要注意的是，因为 Y86-64 指令集不支持使用立即数作为 OPq 运算操作的参数，因此我们使用 %r8 存储 $8$ 这个值，%r9 存储 $-1$ 这个值。

./20230904-csapp-archlab/image-20230904211511036

Part B

Part B 的任务看上去也不算复杂，就是实现 iaddq 指令，将立即数与寄存器相加。

这个任务可以结合书上 SEQ 结构的设计过程，一边翻书一边完成，不算太难。

首先，我们仿照下图的格式，也为 iaddq 指令做一个表格。

./20230904-csapp-archlab/image-20230904212608014

阶段	`iaddq V, rB`
取指	Icde: ifun ← M1[PC] rA:rB ← M1[PC + 1] valC ← M8[PC + 2] valP ← PC + 10
译码	valB ← R[rB]
执行	valE ← valB + valA Set CC
访存
写回	R[rB] ← valE
更新 PC	PC ← valP

然后我们来一个个看每个阶段有哪些信号需要修改。

取指阶段

取指阶段涉及的 HCL 信号如下：

信号	含义
`icode, ifun`	指令码和功能码
`instr_valid`	指令是否合法
`need_regids`	指令是否需要寄存器指示符字节
`need_valC`	指令是否包含立即数

最后的三个信号都需要修改，修改如下：

 bool instr_valid = icode in 
	{ INOP, IHALT, IRRMOVQ, IIRMOVQ, IRMMOVQ, IMRMOVQ,
	       IOPQ, IJXX, ICALL, IRET, IPUSHQ, IPOPQ, IIADDQ };
bool need_regids =
	icode in { IRRMOVQ, IOPQ, IPUSHQ, IPOPQ, 
		     IIRMOVQ, IRMMOVQ, IMRMOVQ, IIADDQ };
bool need_valC =
	icode in { IIRMOVQ, IRMMOVQ, IMRMOVQ, IJXX, ICALL, IIADDQ };

译码阶段和写回阶段

信号	含义
`srcA`, `srcB`	产生值 `valA, valB` 的寄存器
`dstE`	计算结果需要作为目的写入的寄存器
`dstM`	从内存中读取的值需要作为目的写入的寄存器

本阶段需要修改的是 srcB 和 dstE。

 word srcB = [
	icode in { IOPQ, IRMMOVQ, IMRMOVQ, IIADDQ } : rB;
	icode in { IPUSHQ, IPOPQ, ICALL, IRET } : RRSP;
	1 : RNONE;  # Don't need register
];
word dstE = [
	icode in { IRRMOVQ } && Cnd : rB;
	icode in { IIRMOVQ, IOPQ, IIADDQ } : rB;
	icode in { IPUSHQ, IPOPQ, ICALL, IRET } : RRSP;
	1 : RNONE;  # Don't write any register
];

执行阶段

信号	含义
`aluA, aluB`	ALU 的两个输入
`alufun`	ALU 需要执行的功能
`set_cc`	是否更新条件码

除了 alufun 都需要修改。

 word aluA = [
	icode in { IRRMOVQ, IOPQ } : valA;
	icode in { IIRMOVQ, IRMMOVQ, IMRMOVQ, IIADDQ } : valC;
	icode in { ICALL, IPUSHQ } : -8;
	icode in { IRET, IPOPQ } : 8;
	# Other instructions don't need ALU
];
word aluB = [
	icode in { IRMMOVQ, IMRMOVQ, IOPQ, ICALL, 
		      IPUSHQ, IRET, IPOPQ, IIADDQ } : valB;
	icode in { IRRMOVQ, IIRMOVQ } : 0;
	# Other instructions don't need ALU
];
bool set_cc = icode in { IOPQ, IIADDQ };

访存阶段

信号	含义
`mem_read`	是否从内存中读取
`mem_write`	是否向内存中写入
`mem_addr`	设置内存地址
`mem_data`	向内存写入的数据
`Stat`	状态码

不需要更新。

更新 PC 阶段

信号	含义
`new_pc`	新的 PC 地址

不需要更新。

构建和测试

按照实验的文档，我们在终端运行下面的命令构建我们的 SEQ 模拟器。

 make VERSION=full

这时我们可能会遇到一个问题，提示 <tk.h> 头文件不存在。

./20230904-csapp-archlab/image-20230904222844700

必须要在这个文件夹下的 Makefile 文件中找到这三行注释掉即可。

 GUIMODE=-DHAS_GUI
TKLIBS=-L/usr/lib -ltk -ltcl
TKINC=-isystem /usr/include/tcl8.5

编译成功后执行 ./ssim -t ../y86-code/asumi.yo 进行 ISA 测试：

./20230904-csapp-archlab/image-20230904223930655

测试成功！

接下来再使用基准程序进行测试：(cd ../y86-code; make testssim)

./20230904-csapp-archlab/image-20230904224134971

全部成功！

最后是回归测试，运行下面的命令测试除了 iaddq 的所有指令：(cd ../ptest; make SIM=../seq/ssim)。

./20230904-csapp-archlab/image-20230904224513594

运行下面的命令测试 iaddq 指令：(cd ../ptest; make SIM=../seq/ssim TFLAGS=-i)。

./20230904-csapp-archlab/image-20230904224641944

测试通关！

Part C

在这个部分中，实验给我们提供了一个 PIPE 结构的 HCL 实现 pipe-full.hcl，以及一个 Y86-64 程序 ncopy.ys。ncopy.ys 完成了和 Part A 中 copy.ys 类似的功能，不过返回的不是异或和，而是正数的个数。

这个任务的得分是用程序的 CPE 衡量的，如果拷贝 $N$ 个元素需要 $C$ 个时钟周期，那么这个程序的 CPE 就是 $\frac CN$，也就是每元素周期数。如果 CPE 为 $c$，那么这个部分的得分就是：

\[S = \left\{ \begin{aligned} &0,& &c > 10.5\\ &20\cdot (10.5 - c),& & 7.5 \leq c \leq 10.5\\ &60,& & c < 7.5 \end{aligned} \right. \]

也就是说，只有让 CPE 小于 $7.5$ 才能得到满分！

首先记录一下在什么修改也没有做的情况下，我们的 CPE 和得分：

./20230904-csapp-archlab/image-20230904235624417

使用 `iaddq`

原始程序中所有的加法运算都是先将立即数存储到一个寄存器中，然后进行寄存器的加法的。如果我们添加一个 iaddq 指令实现立即数与寄存器相加，那么可以减少一定的操作代价吧。

（不得不说，原始程序在每个循环内部才将立即数存储进寄存器挺傻的……在循环外部预处理以下也不至于那么慢）

pipe-full.hcl 文件修改的方法与 Part B 的部分很类似，这里不再赘述。

修改后的程序如下：

 # %rdi = src, %rsi = dst, %rdx = len
ncopy:
	xorq %rax,%rax		# count = 0;
	andq %rdx,%rdx		# len <= 0?
	jle Done		# if so, goto Done:
Loop:	mrmovq (%rdi), %r10	# read val from src...
	rmmovq %r10, (%rsi)	# ...and store it to dst
	andq %r10, %r10		# val <= 0?
	jle Npos		# if so, goto Npos:
	iaddq $1, %rax		# count++
Npos:
	iaddq $-1, %rdx		# len--
	iaddq $8, %rdi		# src++
	iaddq $8, %rsi		# dst++
	andq %rdx,%rdx		# len > 0?
	jg Loop			# if so, goto Loop:
Done:
	ret

修改后的 CPE：

./20230904-csapp-archlab/image-20230905113721286

还是零分，但是进步不小！

循环展开

循环展开可以减少索引改变的次数，提升计算效率。

我采用了 $8$ 路循环展开。先写出循环展开的 C 程序版本。

 word_t ncopy(word_t *src, word_t *dst, word_t len)
{
    word_t count = 0;
    word_t val;
 
    while (len >= 8) {
        val = *src, *dst = val;
        if (val > 0) count++;
        val = *(src + 1), *(dst + 1) = val;
        if (val > 0) count++;
        val = *(src + 2), *(dst + 2) = val;
        if (val > 0) count++;
        val = *(src + 3), *(dst + 3) = val;
        if (val > 0) count++;
        val = *(src + 4), *(dst + 4) = val;
        if (val > 0) count++;
        val = *(src + 5), *(dst + 5) = val;
        if (val > 0) count++;
        val = *(src + 6), *(dst + 6) = val;
        if (val > 0) count++;
        val = *(src + 7), *(dst + 7) = val;
        if (val > 0) count++;
        len -= 8, src += 8, dst += 8;
    }
    while (len) {
        val = *src++, *dst++ = val;
        if (val > 0) count++;
    }
    return count;
}

转写为汇编程序：

 ncopy:
	xorq %rax,%rax		# count = 0;
	jmp Npos
Loop0:
	mrmovq (%rdi), %r10	# read val from src...
	rmmovq %r10, (%rsi)	# ...and store it to dst
	andq %r10, %r10		# val <= 0?
	jle Loop1			# if so, goto Npos:
	iaddq $1, %rax		# count++
Loop1:
	mrmovq 8(%rdi), %r10	# read val from src...
	rmmovq %r10, 8(%rsi)	# ...and store it to dst
	andq %r10, %r10		# val <= 0?
	jle Loop2			# if so, goto Npos:
	iaddq $1, %rax		# count++
Loop2:
	mrmovq 16(%rdi), %r10	# read val from src...
	rmmovq %r10, 16(%rsi)	# ...and store it to dst
	andq %r10, %r10		# val <= 0?
	jle Loop3			# if so, goto Npos:
	iaddq $1, %rax		# count++
Loop3:
	mrmovq 24(%rdi), %r10	# read val from src...
	rmmovq %r10, 24(%rsi)	# ...and store it to dst
	andq %r10, %r10		# val <= 0?
	jle Loop4			# if so, goto Npos:
	iaddq $1, %rax		# count++
Loop4:
	mrmovq 32(%rdi), %r10	# read val from src...
	rmmovq %r10, 32(%rsi)	# ...and store it to dst
	andq %r10, %r10		# val <= 0?
	jle Loop5			# if so, goto Npos:
	iaddq $1, %rax		# count++
Loop5:
	mrmovq 40(%rdi), %r10	# read val from src...
	rmmovq %r10, 40(%rsi)	# ...and store it to dst
	andq %r10, %r10		# val <= 0?
	jle Loop6			# if so, goto Npos:
	iaddq $1, %rax		# count++
Loop6:
	mrmovq 48(%rdi), %r10	# read val from src...
	rmmovq %r10, 48(%rsi)	# ...and store it to dst
	andq %r10, %r10		# val <= 0?
	jle Loop7			# if so, goto Npos:
	iaddq $1, %rax		# count++
Loop7:
	mrmovq 56(%rdi), %r10	# read val from src...
	rmmovq %r10, 56(%rsi)	# ...and store it to dst
	iaddq $64, %rdi		# src += 8
	iaddq $64, %rsi		# dst += 8
	andq %r10, %r10		# val <= 0?
	jle Npos		# if so, goto Npos:
	iaddq $1, %rax		# count++
Npos:
	iaddq $-8, %rdx		# len -= 8
	jge Loop0			# if so, goto Loop:
	iaddq $8, %rdx
	jle Done
Small:
	mrmovq (%rdi), %r10	# read val from src...
	rmmovq %r10, (%rsi)	# ...and store it to dst
	andq %r10, %r10		# val <= 0?
	jle Test			# if so, goto Npos:
	iaddq $1, %rax		# count++\
Test:
	iaddq $8, %rdi
	iaddq $8, %rsi
	iaddq $-1, %rdx
	jg Small
Done:
	ret

成功把 CPE 降低到了 $9.30$！

./20230904-csapp-archlab/image-20230905125225744

避免加载/使用冒险

注意到下面这样的语句会引起加载/使用冒险，导致一定会引起一个气泡。

 mrmovq (%rdi), %r10	# read val from src...
rmmovq %r10, (%rsi)	# ...and store it to dst

我们可以将两次从内存中读取和两次向内存写入分别合并起来，以此来避免这样的冒险。

 mrmovq (%rdi), %r10
mrmovq 8(%rdi), %r11
rmmovq %r10, (%rsi)
rmmovq %r11, 8(%rsi)

这一步的成果非常显著，我们的 CPE 一下子降低到了 $8.52$。

./20230904-csapp-archlab/image-20230905131212954

再补一个循环展开

注意到我们上一个版本的循环展开中，因为对于剩余的数据没有进行循环展开，导致这个剩余数据的处理中，依然存在加载/使用冲突。我们在这个版本中，将剩余的数据也进行了循环展开，以及消除气泡。

 Npos:
	iaddq $-8, %rdx		# len -= 8
	jge Loop0			# if so, goto Loop:
	iaddq $8, %rdx
	jmp Test
L2_1:
	mrmovq (%rdi), %r10	# read val from src...
	mrmovq 8(%rdi), %r11	# read val from src...
	rmmovq %r10, (%rsi)	# ...and store it to dst
	rmmovq %r11, 8(%rsi)	# ...and store it to dst
	andq %r10, %r10		# val <= 0?
	jle L2_2			# if so, goto Npos:
	iaddq $1, %rax		# count++
L2_2:
	iaddq $16, %rdi
	iaddq $16, %rsi
	andq %r11, %r11		# val <= 0?
	jle Test			# if so, goto Npos:
	iaddq $1, %rax		# count++
Test:
	iaddq $-2, %rdx
	jge L2_1
	iaddq $2, %rdx
	jle Done
	mrmovq (%rdi), %r10	# read val from src...
	rmmovq %r10, (%rsi)	# ...and store it to dst
	andq %r10, %r10		# val <= 0?
	jle Done			# if so, goto Npos:
	iaddq $1, %rax		# count++

效果依然十分显著，CPE 降低到 $8.08$，得分提升到 $48.3$。

./20230904-csapp-archlab/image-20230905134739914

其它优化

将开头的 xorq %rax, %rax 删去，因为程序运行时 %rax 自动被初始化为 $0$ 了。但是这个优化不具备普适性，只能在这个程序中使用。

./20230904-csapp-archlab/image-20230905153446004

提升并不显著，只有 $1$ 分左右。

另外，还有一种优化的方法是将循环展开剩余的部分全部展开写出，使用二分查找的方式定位到展开的代码中。这种方法我尝试过，但是不知道为什么实现的效果并不好。还是等以后有空再尝试继续优化这个方面吧！

posted @ 2024-04-24 13:28 hankeke303 阅读(356) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· CSAPP Lab-3 ATTACKLAB

· CSAPP Lab-8 Proxy lab

· CSAPP-Lab04 Architecture Lab 深入解析

· CSAPP学习笔记——chapter4 处理器体系结构

· CSAPP-Architecture Lab

阅读排行：
· 分享一个免费、快速、无限量使用的满血 DeepSeek R1 模型，支持深度思考和联网搜索！
· 基于 Docker 搭建 FRP 内网穿透开源项目（很简单哒）
· 25岁的心里话
· ollama系列01：轻松3步本地部署deepseek，普通电脑可用
· 按钮权限的设计及实现

公告

我是来自江苏省淮阴中学的hkk同学，欢迎大家光临！
现在是个高二的蒟蒻，什么都不会。

如果有大佬愿意来指导一下萌新，将不胜感激。
QQ: 1131938614
邮箱: hankeke303@163.com

所有校内模拟赛题解的密码皆为校内人人皆知的密码。
日记或者其他的被加密的文章均为博主的姓名每一个音节的首字母的所有排列方式按照字典序无缝拼接以后的字符串的 md5 校验和的 sha256 校验和的 md5 校验和的 base64 编码的 md5 校验和。

昵称： hankeke303
园龄： 7年9个月
粉丝： 30
关注： 24

+加关注

2025年3月

日

一

二

三

四

五

六

hankeke303

亦余心之所善兮，虽九死其犹未悔。

CSAPP Lab-4 Architecture Lab

实验准备

指令集架构

处理器架构

Y86-64 的程序结构

Part A

sum.ys: Iteratively sum linked list elements

rsum.ys: Recursively sum linked list elements

copy.ys: Copy a source block to a destination block

Part B

取指阶段

译码阶段和写回阶段

执行阶段

访存阶段

更新 PC 阶段

构建和测试

Part C

使用 `iaddq`

循环展开

避免加载/使用冒险

再补一个循环展开

其它优化

公告

搜索

常用链接

最新随笔

合集

随笔分类

随笔档案

同学

学长

学弟

阅读排行榜

评论排行榜

推荐排行榜

最新评论

	/* sum_list - Sum the elements of a linked list */
	long sum_list(list_ptr ls)
	{
	long val = 0;
	while (ls) {
	val += ls->val;
	ls = ls->next;
	}
	return val;
	}

	# Sample linked list
	.align 8
	ele1:
	.quad 0x00a
	.quad ele2
	ele2:
	.quad 0x0b0
	.quad ele3
	ele3:
	.quad 0xc00
	.quad 0

	# sum_list - Sum the elements of a linked list
	# by Irilsy

	# Execution begins at address 0
	.pos 0
	irmovq stack, %rsp # Set up stack pointer
	call main # Execute main program
	halt # Terminate program

	# Sample linked list
	.align 8
	ele1:
	.quad 0x00a
	.quad ele2
	ele2:
	.quad 0x0b0
	.quad ele3
	ele3:
	.quad 0xc00
	.quad 0

	main:
	irmovq ele1, %rdi
	call sum_list
	ret

	sum_list:
	xorq %rax, %rax
	jmp test
	loop:
	mrmovq (%rdi), %rsi
	addq %rsi, %rax
	mrmovq 8(%rdi), %rdi
	test:
	andq %rdi, %rdi
	jne loop
	ret

	# Stack starts here and grows to lower addresses
	.pos 0x200
	stack:

	/* rsum_list - Recursive version of sum_list */
	long rsum_list(list_ptr ls)
	{
	if (!ls)
	return 0;
	else {
	long val = ls->val;
	long rest = rsum_list(ls->next);
	return val + rest;
	}
	}

	# rsum_list - Sum the elements of a linked list
	# by Irilsy

	# Execution begins at address 0
	.pos 0
	irmovq stack, %rsp # Set up stack pointer
	call main # Execute main program
	halt # Terminate program

	# Sample linked list
	.align 8
	ele1:
	.quad 0x00a
	.quad ele2
	ele2:
	.quad 0x0b0
	.quad ele3
	ele3:
	.quad 0xc00
	.quad 0

	main:
	irmovq ele1, %rdi
	call rsum_list
	ret

	rsum_list:
	xorq %rax, %rax
	andq %rdi, %rdi
	je end
	pushq %rbx
	mrmovq (%rdi), %rbx
	mrmovq 8(%rdi), %rdi
	call rsum_list
	addq %rbx, %rax
	popq %rbx
	end:
	ret

	# Stack starts here and grows to lower addresses
	.pos 0x200
	stack:

	/* copy_block - Copy src to dest and return xor checksum of src */
	long copy_block(long src, long dest, long len)
	{
	long result = 0;
	while (len > 0) {
	long val = *src++;
	*dest++ = val;
	result ^= val;
	len--;
	}
	return result;
	}

	# Source block
	src:
	.quad 0x00a
	.quad 0x0b0
	.quad 0xc00

	# Destination block
	dest:
	.quad 0x111
	.quad 0x222
	.quad 0x333

	# copy_block - Sum the elements of a linked list
	# by Irilsy

	# Execution begins at address 0
	.pos 0
	irmovq stack, %rsp # Set up stack pointer
	call main # Execute main program
	halt # Terminate program

	.align 8
	# Source block
	src:
	.quad 0x00a
	.quad 0x0b0
	.quad 0xc00

	# Destination block
	dest:
	.quad 0x111
	.quad 0x222
	.quad 0x333

	main:
	irmovq src, %rdi
	irmovq dest, %rsi
	irmovq $3, %rdx
	call copy_block
	ret

	copy_block:
	xorq %rax, %rax
	irmovq $8, %r8
	irmovq $-1, %r9
	jmp test
	loop:
	mrmovq (%rdi), %rcx
	addq %r8, %rdi
	rmmovq %rcx, (%rsi)
	addq %r8, %rsi
	xorq %rcx, %rax
	addq %r9, %rdx
	test:
	andq %rdx, %rdx
	jg loop

	# Stack starts here and grows to lower addresses
	.pos 0x200
	stack:

	bool instr_valid = icode in
	{ INOP, IHALT, IRRMOVQ, IIRMOVQ, IRMMOVQ, IMRMOVQ,
	IOPQ, IJXX, ICALL, IRET, IPUSHQ, IPOPQ, IIADDQ };
	bool need_regids =
	icode in { IRRMOVQ, IOPQ, IPUSHQ, IPOPQ,
	IIRMOVQ, IRMMOVQ, IMRMOVQ, IIADDQ };
	bool need_valC =
	icode in { IIRMOVQ, IRMMOVQ, IMRMOVQ, IJXX, ICALL, IIADDQ };

	word srcB = [
	icode in { IOPQ, IRMMOVQ, IMRMOVQ, IIADDQ } : rB;
	icode in { IPUSHQ, IPOPQ, ICALL, IRET } : RRSP;
	1 : RNONE; # Don't need register
	];
	word dstE = [
	icode in { IRRMOVQ } && Cnd : rB;
	icode in { IIRMOVQ, IOPQ, IIADDQ } : rB;
	icode in { IPUSHQ, IPOPQ, ICALL, IRET } : RRSP;
	1 : RNONE; # Don't write any register
	];

	word aluA = [
	icode in { IRRMOVQ, IOPQ } : valA;
	icode in { IIRMOVQ, IRMMOVQ, IMRMOVQ, IIADDQ } : valC;
	icode in { ICALL, IPUSHQ } : -8;
	icode in { IRET, IPOPQ } : 8;
	# Other instructions don't need ALU
	];
	word aluB = [
	icode in { IRMMOVQ, IMRMOVQ, IOPQ, ICALL,
	IPUSHQ, IRET, IPOPQ, IIADDQ } : valB;
	icode in { IRRMOVQ, IIRMOVQ } : 0;
	# Other instructions don't need ALU
	];
	bool set_cc = icode in { IOPQ, IIADDQ };

	GUIMODE=-DHAS_GUI
	TKLIBS=-L/usr/lib -ltk -ltcl
	TKINC=-isystem /usr/include/tcl8.5

	# %rdi = src, %rsi = dst, %rdx = len
	ncopy:
	xorq %rax,%rax # count = 0;
	andq %rdx,%rdx # len <= 0?
	jle Done # if so, goto Done:
	Loop: mrmovq (%rdi), %r10 # read val from src...
	rmmovq %r10, (%rsi) # ...and store it to dst
	andq %r10, %r10 # val <= 0?
	jle Npos # if so, goto Npos:
	iaddq $1, %rax # count++
	Npos:
	iaddq $-1, %rdx # len--
	iaddq $8, %rdi # src++
	iaddq $8, %rsi # dst++
	andq %rdx,%rdx # len > 0?
	jg Loop # if so, goto Loop:
	Done:
	ret

	word_t ncopy(word_t src, word_t dst, word_t len)
	{
	word_t count = 0;
	word_t val;

	while (len >= 8) {
	val = src, dst = val;
	if (val > 0) count++;
	val = (src + 1), (dst + 1) = val;
	if (val > 0) count++;
	val = (src + 2), (dst + 2) = val;
	if (val > 0) count++;
	val = (src + 3), (dst + 3) = val;
	if (val > 0) count++;
	val = (src + 4), (dst + 4) = val;
	if (val > 0) count++;
	val = (src + 5), (dst + 5) = val;
	if (val > 0) count++;
	val = (src + 6), (dst + 6) = val;
	if (val > 0) count++;
	val = (src + 7), (dst + 7) = val;
	if (val > 0) count++;
	len -= 8, src += 8, dst += 8;
	}
	while (len) {
	val = src++, dst++ = val;
	if (val > 0) count++;
	}
	return count;
	}

	ncopy:
	xorq %rax,%rax # count = 0;
	jmp Npos
	Loop0:
	mrmovq (%rdi), %r10 # read val from src...
	rmmovq %r10, (%rsi) # ...and store it to dst
	andq %r10, %r10 # val <= 0?
	jle Loop1 # if so, goto Npos:
	iaddq $1, %rax # count++
	Loop1:
	mrmovq 8(%rdi), %r10 # read val from src...
	rmmovq %r10, 8(%rsi) # ...and store it to dst
	andq %r10, %r10 # val <= 0?
	jle Loop2 # if so, goto Npos:
	iaddq $1, %rax # count++
	Loop2:
	mrmovq 16(%rdi), %r10 # read val from src...
	rmmovq %r10, 16(%rsi) # ...and store it to dst
	andq %r10, %r10 # val <= 0?
	jle Loop3 # if so, goto Npos:
	iaddq $1, %rax # count++
	Loop3:
	mrmovq 24(%rdi), %r10 # read val from src...
	rmmovq %r10, 24(%rsi) # ...and store it to dst
	andq %r10, %r10 # val <= 0?
	jle Loop4 # if so, goto Npos:
	iaddq $1, %rax # count++
	Loop4:
	mrmovq 32(%rdi), %r10 # read val from src...
	rmmovq %r10, 32(%rsi) # ...and store it to dst
	andq %r10, %r10 # val <= 0?
	jle Loop5 # if so, goto Npos:
	iaddq $1, %rax # count++
	Loop5:
	mrmovq 40(%rdi), %r10 # read val from src...
	rmmovq %r10, 40(%rsi) # ...and store it to dst
	andq %r10, %r10 # val <= 0?
	jle Loop6 # if so, goto Npos:
	iaddq $1, %rax # count++
	Loop6:
	mrmovq 48(%rdi), %r10 # read val from src...
	rmmovq %r10, 48(%rsi) # ...and store it to dst
	andq %r10, %r10 # val <= 0?
	jle Loop7 # if so, goto Npos:
	iaddq $1, %rax # count++
	Loop7:
	mrmovq 56(%rdi), %r10 # read val from src...
	rmmovq %r10, 56(%rsi) # ...and store it to dst
	iaddq $64, %rdi # src += 8
	iaddq $64, %rsi # dst += 8
	andq %r10, %r10 # val <= 0?
	jle Npos # if so, goto Npos:
	iaddq $1, %rax # count++
	Npos:
	iaddq $-8, %rdx # len -= 8
	jge Loop0 # if so, goto Loop:
	iaddq $8, %rdx
	jle Done
	Small:
	mrmovq (%rdi), %r10 # read val from src...
	rmmovq %r10, (%rsi) # ...and store it to dst
	andq %r10, %r10 # val <= 0?
	jle Test # if so, goto Npos:
	iaddq $1, %rax # count++\
	Test:
	iaddq $8, %rdi
	iaddq $8, %rsi
	iaddq $-1, %rdx
	jg Small
	Done:
	ret

	mrmovq (%rdi), %r10
	mrmovq 8(%rdi), %r11
	rmmovq %r10, (%rsi)
	rmmovq %r11, 8(%rsi)

hankeke303

亦余心之所善兮，虽九死其犹未悔。

CSAPP Lab-4 Architecture Lab

实验准备

指令集架构

处理器架构

Y86-64 的程序结构

Part A

sum.ys: Iteratively sum linked list elements

rsum.ys: Recursively sum linked list elements

copy.ys: Copy a source block to a destination block

Part B

取指阶段

译码阶段和写回阶段

执行阶段

访存阶段

更新 PC 阶段

构建和测试

Part C

使用 iaddq

循环展开

避免加载/使用冒险

再补一个循环展开

其它优化

公告

搜索

常用链接

最新随笔

合集

随笔分类

随笔档案

同学

学长

学弟

阅读排行榜

评论排行榜

推荐排行榜

最新评论

使用 `iaddq`