穷且益坚，不坠青云之志。
Arch Lab 实验分为三部分。在 A 部分中，需要我们写一些简单的Y86-64程序，从而熟悉Y86-64工具的使用；在 B 部分中，我们要用一个新的指令来扩展SEQ；C 部分是本实验的核心，我们要通过理解流水线的过程以及利用新的指令来优化程序。
实验材料中有一个archlab.pdf，按照文档一步步往下走就可以了。make时，可能会缺少相关依赖，安装如下软件即可
sudo apt install tcl tcl-dev tk tk-devsudo apt install flexsudo apt install bison在这部分，要用Y86-64汇编代码实现examples.c中的三个函数。这三个函数都是与链表有关的操作，链表结点定义如下
/* linked list element */typedef struct ELE { long val; struct ELE *next;} *list_ptr;在编写汇编代码之前，我们先回顾一下Y86-64的指令集：
# movq i-->r: 从立即数到寄存器...irmovq, rrmovq, mrmovq, rmmovq# Opqaddq, subq, andq, xorq# 跳转 jXXjmp, jle, jl, je, jne, jge, jg# 条件传送 cmovXXcmovle, cmovl, cmove, cmovne, cmovge, cmovgcall, retpushq, popq# 停止指令的执行halt# 寄存器%rax, %rcx, %rdx%rbx, %rsp, %rbp%rsi, %rdi, %r8%r9, %r10, %r11%r12, %r13, %r14/* 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;}本题就是一个链表求和，非常简单。但要注意，这里不仅要写出函数段，还应该写出测试的代码段。直接给出转换后的汇编代码：
# sum_list - Sum the elements of a linked list# author: Deconx# 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 8ele1: .quad 0x00a .quad ele2ele2: .quad 0x0b0 .quad ele3ele3: .quad 0xc00 .quad 0main: irmovq ele1,%rdi call sum_list ret# long sum_list(list_ptr ls)# start in %rdisum_list: irmovq $0, %rax jmp testloop: mrmovq (%rdi), %rsi addq %rsi, %rax mrmovq 8(%rdi), %rditest: andq %rdi, %rdi jne loop ret# Stack starts here and grows to lower addresses .pos 0x200stack: 注意，应在stack下方空一行，否则汇编器会报错，报错原因我也不清楚。
利用实验文件中给的YAS汇编器进行汇编，YIS指令集模拟器运行测试
./yas sum.ys./yis sum.yo得到结果
返回值%rax=0xcba=0x00a+0x0b0+0xc00，结果正确！
/* 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; }}这是链表求和的递归实现，按照C语言代码的过程模拟即可，思路非常清晰，可以参考我的注释
# /* rsum_list - Recursive version of sum_list */# author: Deconx# 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 8ele1: .quad 0x00a .quad ele2ele2: .quad 0x0b0 .quad ele3ele3: .quad 0xc00 .quad 0main: irmovq ele1,%rdi call rsum_list ret# long sum_list(list_ptr ls)# start in %rdirsum_list: andq %rdi, %rdi je return # if(!ls) mrmovq (%rdi), %rbx # val = ls->val mrmovq 8(%rdi), %rdi # ls = ls->next pushq %rbx call rsum_list # rsum_list(ls->next) popq %rbx addq %rbx, %rax # val + rest retreturn: irmovq $0, %rax ret# Stack starts here and grows to lower addresses .pos 0x200stack: 测试
结果正确！
/* 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;}数组赋值操作，返回值为原数组各项的按位异或
这段代码的架构与书上图 4-7的例子完全相同，包括常数的处理，循环的设置技巧，退出循环的判断... 照猫画虎即可，当然，我也在后面附上了注释
/* copy_block - Copy src to dest and return xor checksum of src */# author: Deconx# Execution begins at address 0 .pos 0 irmovq stack, %rsp # Set up stack pointer call main # Execute main program halt # Terminate program# Sample .align 8# Source blocksrc: .quad 0x00a .quad 0x0b0 .quad 0xc00# Destination blockdest: .quad 0x111 .quad 0x222 .quad 0x333main: irmovq src, %rdi # src irmovq dest, %rsi # dest irmovq $3, %rdx # len call copy_block ret# long copy_block(long *src, long *dest, long len)# src in %rdi# dest in %rsi# len in %rdxcopy_block: irmovq $8, %r8 irmovq $1, %r9 irmovq $0, %rax andq %rdx, %rdx jmp testloop: mrmovq (%rdi), %r10 # val = *src1 addq %r8, %rdi # src++ rmmovq %r10, (%rsi) # *dest = val addq %r8, %rsi # dest++ xorq %r10, %rax # result ^= val subq %r9, %rdx # len--. Set CCtest: jne loop # Stop when 0 ret # Stack starts here and grows to lower addresses .pos 0x200stack: 编译运行一下
结果完全正确
Part B 整合了第 4 章的 homework - 4.51, 4.52。就是实现iaddq指令，将立即数与寄存器相加。可以参考irmovq和OPq指令的计算。在开始之前，我们还是先回顾一下处理一条指令的各个阶段吧！
icode:ifunrA, rBvalCvalPrA, rB 指明的寄存器，读为 valA, valBpopq, pushq, call, ret也可能从%rsp中读ifun计算，或计算内存引用的有效地址，或增加或减少栈指针valEvalMiaddq指令执行过程iaddq的执行与Opq非常相似，后者需要取出rA与rB分别指示的寄存器进行运算后再写回rB指示的寄存器。而前者与后者唯一的区别就是，不需要从rA中取数，直接立即数计算即可。
指令为：iaddq V, rB取指： icode:ifun <- M_1[PC] rA:rB <- M_1[PC+1] valC <- M_8[PC+2] valP <- PC+10译码： valB <- R[rB]执行： valE <- valB + valC Set CC访存： 写回： R[rB] <- valE更新PC： PC <- valPHCL代码接下来要在seq-full.hcl文件中修改代码。由于iaddq的操作与OPq和irmovq类似，比较取巧的做法是，搜索有这两个指令的描述块进行修改即可。本着学习的目的，我们分阶段对所有信号逐个分析
取指阶段
instr_valid：判断指令是否合法，当然应该加上。修改后为
bool instr_valid = icode in { INOP, IHALT, IRRMOVQ, IIRMOVQ, IRMMOVQ, IMRMOVQ, IOPQ, IJXX, ICALL, IRET, IPUSHQ, IPOPQ, IIADDQ };need_regids：判断指令是否包括寄存器指示符字节，当然也应该加上
bool need_regids = icode in { IRRMOVQ, IOPQ, IPUSHQ, IPOPQ, IIRMOVQ, IRMMOVQ, IMRMOVQ, IIADDQ };need_valC：判断指令是否包括常数字，还是要加上
bool need_valC = icode in { IIRMOVQ, IRMMOVQ, IMRMOVQ, IJXX, ICALL, IIADDQ };译码和写回阶段
srcB：赋为产生valB的寄存器。译码阶段要从rA, rB 指明的寄存器读为 valA, valB，而iaddq有一个rB，于是有以下修改
word srcB = [ icode in { IOPQ, IRMMOVQ, IMRMOVQ, IIADDQ } : rB; icode in { IPUSHQ, IPOPQ, ICALL, IRET } : RRSP; 1 : RNONE; # Don't need register];dst_E：表明写端口 E 的目的寄存器，计算出来的值valE将放在那里。最终结果要存放在rB中，所以要修改
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];执行阶段
执行阶段ALU要对aluA和aluB进行计算，计算格式为：aluB OP aluA。所以aluaA可以是valA和valC或者+-8，aluaB只能是valB。而iaddq执行阶段进行的运算是valB + valC，于是可知修改
## Select input A to ALUword 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];## Select input B to ALUword aluB = [ icode in { IRMMOVQ, IMRMOVQ, IOPQ, ICALL, IPUSHQ, IRET, IPOPQ, IIADDQ } : valB; icode in { IRRMOVQ, IIRMOVQ } : 0; # Other instructions don't need ALU];set_cc：判断是否应该更新条件码寄存器，这里应该加上
bool set_cc = icode in { IOPQ, IIADDQ };访存阶段
iaddq没有访存阶段，无需修改
更新PC阶段
iaddq不涉及转移等操作，也无需修改
SEQ编译ssim的时候出现了很多问题：
提示不存在tk.h这个头文件，这是由于实验文件太老。把Makefile修改一下。第 20 行改为
TKINC=-isystem /usr/include/tcl8.6第 26 行改为
CFLAGS=-Wall -O2 -DUSE_INTERP_RESULT但是接下来还是报错了
/usr/bin/ld: /tmp/ccKTMI04.o:(.data.rel+0x0): undefined reference to `matherr'collect2: error: ld returned 1 exit statusmake: *** [Makefile:44: ssim] Error 1这是因为较新版本glibc弃用了这部分内容
解决办法是注释掉 /sim/pipe/psim.c 806、807 line和 /sim/seq/ssim.c 844、845 line。即：有源代码中有matherr的一行和它的下一行
接下来就能编译成功了！虽然会有很多 Warning
第一轮测试
运行一个简单的Y86-64 程序，并将结果ISA模拟器的结果进行比对，输出如下
> ./ssim -t ../y86-code/asumi.yoY86-64 Processor: seq-full.hcl137 bytes of code readIF: Fetched irmovq at 0x0. ra=----, rb=%rsp, valC = 0x100IF: Fetched call at 0xa. ra=----, rb=----, valC = 0x38Wrote 0x13 to address 0xf8IF: Fetched irmovq at 0x38. ra=----, rb=%rdi, valC = 0x18IF: Fetched irmovq at 0x42. ra=----, rb=%rsi, valC = 0x4IF: Fetched call at 0x4c. ra=----, rb=----, valC = 0x56Wrote 0x55 to address 0xf0IF: Fetched xorq at 0x56. ra=%rax, rb=%rax, valC = 0x0IF: Fetched andq at 0x58. ra=%rsi, rb=%rsi, valC = 0x0IF: Fetched jmp at 0x5a. ra=----, rb=----, valC = 0x83IF: Fetched jne at 0x83. ra=----, rb=----, valC = 0x63IF: Fetched mrmovq at 0x63. ra=%r10, rb=%rdi, valC = 0x0IF: Fetched addq at 0x6d. ra=%r10, rb=%rax, valC = 0x0IF: Fetched iaddq at 0x6f. ra=----, rb=%rdi, valC = 0x8IF: Fetched iaddq at 0x79. ra=----, rb=%rsi, valC = 0xffffffffffffffffIF: Fetched jne at 0x83. ra=----, rb=----, valC = 0x63IF: Fetched mrmovq at 0x63. ra=%r10, rb=%rdi, valC = 0x0IF: Fetched addq at 0x6d. ra=%r10, rb=%rax, valC = 0x0IF: Fetched iaddq at 0x6f. ra=----, rb=%rdi, valC = 0x8IF: Fetched iaddq at 0x79. ra=----, rb=%rsi, valC = 0xffffffffffffffffIF: Fetched jne at 0x83. ra=----, rb=----, valC = 0x63IF: Fetched mrmovq at 0x63. ra=%r10, rb=%rdi, valC = 0x0IF: Fetched addq at 0x6d. ra=%r10, rb=%rax, valC = 0x0IF: Fetched iaddq at 0x6f. ra=----, rb=%rdi, valC = 0x8IF: Fetched iaddq at 0x79. ra=----, rb=%rsi, valC = 0xffffffffffffffffIF: Fetched jne at 0x83. ra=----, rb=----, valC = 0x63IF: Fetched mrmovq at 0x63. ra=%r10, rb=%rdi, valC = 0x0IF: Fetched addq at 0x6d. ra=%r10, rb=%rax, valC = 0x0IF: Fetched iaddq at 0x6f. ra=----, rb=%rdi, valC = 0x8IF: Fetched iaddq at 0x79. ra=----, rb=%rsi, valC = 0xffffffffffffffffIF: Fetched jne at 0x83. ra=----, rb=----, valC = 0x63IF: Fetched ret at 0x8c. ra=----, rb=----, valC = 0x0IF: Fetched ret at 0x55. ra=----, rb=----, valC = 0x0IF: Fetched halt at 0x13. ra=----, rb=----, valC = 0x032 instructions executedStatus = HLTCondition Codes: Z=1 S=0 O=0Changed Register State:%rax: 0x0000000000000000 0x0000abcdabcdabcd%rsp: 0x0000000000000000 0x0000000000000100%rdi: 0x0000000000000000 0x0000000000000038%r10: 0x0000000000000000 0x0000a000a000a000Changed Memory State:0x00f0: 0x0000000000000000 0x00000000000000550x00f8: 0x0000000000000000 0x0000000000000013ISA Check Succeeds成功！
标准测试
运行一个标准检查程序
> cd ../y86-code; make testssim../seq/ssim -t asum.yo > asum.seq../seq/ssim -t asumr.yo > asumr.seq../seq/ssim -t cjr.yo > cjr.seq../seq/ssim -t j-cc.yo > j-cc.seq../seq/ssim -t poptest.yo > poptest.seq../seq/ssim -t pushquestion.yo > pushquestion.seq../seq/ssim -t pushtest.yo > pushtest.seq../seq/ssim -t prog1.yo > prog1.seq../seq/ssim -t prog2.yo > prog2.seq../seq/ssim -t prog3.yo > prog3.seq../seq/ssim -t prog4.yo > prog4.seq../seq/ssim -t prog5.yo > prog5.seq../seq/ssim -t prog6.yo > prog6.seq../seq/ssim -t prog7.yo > prog7.seq../seq/ssim -t prog8.yo > prog8.seq../seq/ssim -t ret-hazard.yo > ret-hazard.seqgrep "ISA Check" *.seqasum.seq:ISA Check Succeedsasumr.seq:ISA Check Succeedscjr.seq:ISA Check Succeedsj-cc.seq:ISA Check Succeedspoptest.seq:ISA Check Succeedsprog1.seq:ISA Check Succeedsprog2.seq:ISA Check Succeedsprog3.seq:ISA Check Succeedsprog4.seq:ISA Check Succeedsprog5.seq:ISA Check Succeedsprog6.seq:ISA Check Succeedsprog7.seq:ISA Check Succeedsprog8.seq:ISA Check Succeedspushquestion.seq:ISA Check Succeedspushtest.seq:ISA Check Succeedsret-hazard.seq:ISA Check Succeedsrm asum.seq asumr.seq cjr.seq j-cc.seq poptest.seq pushquestion.seq pushtest.seq prog1.seq prog2.seq prog3.seq prog4.seq prog5.seq prog6.seq prog7.seq prog8.seq ret-hazard.seq全部都是 Succeeds
回归测试
测试除iaddq的所有指令
专门测试iaddq指令
于是，我们就通过了实验材料中的所有测试用例！
Part C 在sim/pipe中进行。PIPE 是使用了转发技术的流水线化的Y86-64处理器。它相比 Part B 增加了流水线寄存器和流水线控制逻辑。
在本部分中，我们要通过修改pipe-full.hcl和ncopy.ys来优化程序，通过程序的效率，也就是 CPE 来计算我们的分数，分数由下述公式算出
首先，iaddq是一个非常好的指令，它可以把两步简化为一步，所以我们先修改pipe-full.hcl，增加iaddq指令，修改参考 Part B 即可。稳妥起见，修改后还是应该测试一下这个模拟器，Makefile参考 Part B 部分进行同样的修改后编译。然后执行以下命令进行测试：
./psim -t ../y86-code/asumi.yocd ../ptest; make SIM=../pipe/psimcd ../ptest; make SIM=../pipe/psim TFLAGS=-i当所有测试都显示 Succeed 后，就可以真正开始本部分的重头戏了！
ncopy函数将一个长度为len的整型数组src复制到一个不重叠的数组dst，并返回src中正数的个数。C 语言代码如下
/* * ncopy - copy src to dst, returning number of positive ints * contained in src array. */word_t ncopy(word_t *src, word_t *dst, word_t len){ word_t count = 0; word_t val; while (len > 0) { val = *src++; *dst++ = val; if (val > 0) count++; len--; } return count;}原汇编代码如下：
# You can modify this portion # Loop header 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: irmovq $1, %r10 addq %r10, %rax # count++Npos: irmovq $1, %r10 subq %r10, %rdx # len-- irmovq $8, %r10 addq %r10, %rdi # src++ addq %r10, %rsi # dst++ andq %rdx,%rdx # len > 0? jg Loop # if so, goto Loop:先分别执行以下命令，对原始代码测试一波 CPE
./correctness.pl./benchmark.pl得
Average CPE 15.18Score 0.0/60.0iaddq首先能够直观看到，为了len--/src++/dst++等操作，对%rdi进行了不少次赋值操作，这些都可以用我们新增的iaddq指令替代。
替代后代码为
# You can modify this portion # Loop header 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:测试 CPE
Average CPE 12.70Score 0.0/60.0虽然分数还是0，但已经有了不少提升
根据文档的提示，可以试试循环展开进行优化。 循环展开通过增加每次迭代计算的元素的数量，减少循环的迭代次数。这样做对效率提升有什么作用呢？
那么展开几路效率最高呢？我从5路展开开始分别进行了测试
5路： Average CPE 9.61 Score 17.8/60.06路： Average CPE 9.58 Score 18.3/60.0 7路： Average CPE 9.59 Score 18.2/60.0 8路： Average CPE 9.62 Score 17.5/60.0所以，我选择进行6路展开
# Loop header andq %rdx,%rdx # len <= 0? jmp testLoop: mrmovq (%rdi),%r8 rmmovq %r8,(%rsi) andq %r8,%r8 jle Loop1 iaddq $1,%raxLoop1: mrmovq 8(%rdi),%r8 rmmovq %r8,8(%rsi) andq %r8,%r8 jle Loop2 iaddq $1,%raxLoop2: mrmovq 16(%rdi),%r8 rmmovq %r8,16(%rsi) andq %r8,%r8 jle Loop3 iaddq $1,%raxLoop3: mrmovq 24(%rdi),%r8 rmmovq %r8,24(%rsi) andq %r8,%r8 jle Loop4 iaddq $1,%raxLoop4: mrmovq 32(%rdi),%r8 rmmovq %r8,32(%rsi) andq %r8,%r8 jle Loop5 iaddq $1,%raxLoop5: mrmovq 40(%rdi),%r8 rmmovq %r8,40(%rsi) iaddq $48,%rdi iaddq $48,%rsi andq %r8,%r8 jle test iaddq $1,%rax test: iaddq $-6, %rdx # 先减，判断够不够6个 jge Loop # 6路展开 iaddq $-8,%rdi iaddq $-8,%rsi iaddq $6, %rdx jmp test2 #剩下的Lore: mrmovq (%rdi),%r8 rmmovq %r8,(%rsi) andq %r8,%r8 jle test2 iaddq $1,%raxtest2: iaddq $8,%rdi iaddq $8,%rsi iaddq $-1, %rdx jge Lore代码逻辑非常简单：每次循环都对6个数进行复制，每次复制就设置一个条件语句判断返回时是否加1，对于剩下的数据每次循环只对1个数进行复制。
为了方便分析，我把极端的几个例子的情况列下来：
ncopy0 261 35 35.002 47 23.503 56 18.674 68 17.005 77 15.406 69 11.507 78 11.148 90 11.259 99 11.0010 111 11.1011 120 10.9112 112 9.3313 121 9.3114 133 9.5015 142 9.4716 154 9.6217 163 9.5918 155 8.61...50 391 7.8251 400 7.8452 412 7.9253 421 7.9454 413 7.6555 422 7.6756 434 7.7557 443 7.7758 455 7.8459 464 7.8660 456 7.6061 465 7.6262 477 7.6963 486 7.7164 498 7.78Average CPE 9.58Score 18.3/60.0观察上表，对于小数据而言， CPE 的值非常大，后续可以考虑对小数据进行优化。我们先优化剩余数据的处理，对他们继续进行循环展开。
对于剩余数据，我选择3路循环展开。前面的6路与上面代码一样，我就不再贴出来了
# Loop header andq %rdx,%rdx # len <= 0? jmp testLoop:...Loop1:......Loop4:...Loop5:...test: iaddq $-6, %rdx # 先减，判断够不够6个 jge Loop # 6路展开 iaddq $6, %rdx jmp test2 #剩下的L: mrmovq (%rdi),%r8 rmmovq %r8,(%rsi) andq %r8,%r8 jle L1 iaddq $1,%raxL1: mrmovq 8(%rdi),%r8 rmmovq %r8,8(%rsi) andq %r8,%r8 jle L2 iaddq $1,%raxL2: mrmovq 16(%rdi),%r8 rmmovq %r8,16(%rsi) iaddq $24,%rdi iaddq $24,%rsi andq %r8,%r8 jle test2 iaddq $1,%raxtest2: iaddq $-3, %rdx # 先减，判断够不够3个 jge L iaddq $2, %rdx # -1则不剩了，直接Done,0 剩一个, 1剩2个 je R0 jl Done mrmovq (%rdi),%r8 rmmovq %r8,(%rsi) andq %r8,%r8 jle R2 iaddq $1,%raxR2: mrmovq 8(%rdi),%r8 rmmovq %r8,8(%rsi) andq %r8,%r8 jle Done iaddq $1,%rax jmp DoneR0: mrmovq (%rdi),%r8 rmmovq %r8,(%rsi) andq %r8,%r8 jle Done iaddq $1,%rax注意对于3路展开的特殊处理。看第38、39行，通过直接判断剩余数据的数量减少一次条件判断
CPE 值为
Average CPE 9.07Score 28.5/60.0提升了很多，但是依然连一般的分数都还没拿到...
注意，程序多次使用了下面的操作：
mrmovq (%rdi), %r8rmmovq %r8, (%rsi)Y86-64处理器的流水线有 F(取指)、D(译码)、E(执行)、M(访存)、W(写回) 五个阶段，D 阶段才读取寄存器，M 阶段才读取对应内存值，
即使使用转发来避免数据冒险，这其中也至少会有一个气泡。像这样
mrmovq (%rdi), %r8bubblermmovq %r8, (%rsi)一个优化办法是，多取一个寄存器，连续进行两次数据复制。
mrmovq (%rdi), %r8mrmovq 8(%rdi), %r9rmmovq %r8, (%rsi)rmmovq %r9, 8(%rsi)像这样，对%r8和%r9进行读入和读出的操作之间都隔着一条其他指令，就不会有气泡产生了。代码如下：
# Loop header andq %rdx,%rdx # len <= 0? jmp testLoop: mrmovq (%rdi),%r8 mrmovq 8(%rdi),%r9 andq %r8,%r8 rmmovq %r8,(%rsi) rmmovq %r9,8(%rsi) jle Loop1 iaddq $1,%raxLoop1: andq %r9,%r9 jle Loop2 iaddq $1,%raxLoop2: mrmovq 16(%rdi),%r8 mrmovq 24(%rdi),%r9 andq %r8,%r8 rmmovq %r8,16(%rsi) rmmovq %r9,24(%rsi) jle Loop3 iaddq $1,%raxLoop3: andq %r9,%r9 jle Loop4 iaddq $1,%raxLoop4: mrmovq 32(%rdi),%r8 mrmovq 40(%rdi),%r9 andq %r8,%r8 rmmovq %r8,32(%rsi) rmmovq %r9,40(%rsi) jle Loop5 iaddq $1,%raxLoop5: iaddq $48,%rdi iaddq $48,%rsi andq %r9,%r9 jle test iaddq $1,%raxtest: iaddq $-6, %rdx # 先减，判断够不够6个 jge Loop # 6路展开 iaddq $6, %rdx jmp test2 #剩下的L: mrmovq (%rdi),%r8 andq %r8,%r8 rmmovq %r8,(%rsi) jle L1 iaddq $1,%raxL1: mrmovq 8(%rdi),%r8 andq %r8,%r8 rmmovq %r8,8(%rsi) jle L2 iaddq $1,%raxL2: mrmovq 16(%rdi),%r8 iaddq $24,%rdi rmmovq %r8,16(%rsi) iaddq $24,%rsi andq %r8,%r8 jle test2 iaddq $1,%raxtest2: iaddq $-3, %rdx # 先减，判断够不够3个 jge L iaddq $2, %rdx # -1则不剩了，直接Done,0 剩一个, 1剩2个 je R0 jl Done mrmovq (%rdi),%r8 mrmovq 8(%rdi),%r9 rmmovq %r8,(%rsi) rmmovq %r9,8(%rsi) andq %r8,%r8 jle R2 iaddq $1,%raxR2: andq %r9,%r9 jle Done iaddq $1,%rax jmp DoneR0: mrmovq (%rdi),%r8 andq %r8,%r8 rmmovq %r8,(%rsi) jle Done iaddq $1,%rax注意，只有rmmovq不改变条件寄存器的值，所以我们也可以把andq插进中间来消除气泡。
CPE 值为
Average CPE 8.16Score 46.9/60.0这一步的提升是巨大的！我的分数终于像点样子了！
这里先留个坑。
暂且截图记录我目前为止的最高成就：
运行正确：
分数为：46.8
Y86-64模拟器、测试工具供我们学习。本实验尤其是 Part C 每优化一次就能立即看到自己的分数，这犹如游戏闯关一般的体验令我着迷。这一切要归功于两位老师细致的设计，希望有生之年能见他们一次！