[时间戳] 我的第一个 RISC-V 程序！

三路快排，枢轴量默认取中间元素（随机数不太好弄），测试环境为 venus。

main:
    li t0, -800
    add sp, sp, t0 # allocate stack space
 
    li t0, 0
    li t1, 200
    mv t2, sp # prepare loop infomation
    LOOP0_BEGIN:
        bge t0, t1, LOOP0_EXIT
        sub t3, t1, t0
        sw t3, 0(t2) # loop body
 
        addi t0, t0, 1
        addi t2, t2, 4 # modify loop variables
        j LOOP0_BEGIN
    LOOP0_EXIT:
 
    mv a0, sp
    li a1, 0
    li a2, 199
    jal quick_sort
 
    li a1, 0 # success
    li t0, 1 # i
    li t1, 200
    addi t2, sp, 4 # arr[1] initially
    LOOP1_BEGIN:
        bge t0, t1, LOOP1_EXIT
 
        lw t3, -4(t2) # arr[i - 1]
        lw t4, 0(t2) # arr[i]
        bge t4, t3, LOOP1_CONT  # arr[i] >= arr[i - 1] ?
        li a1, 233 # report failure
        j LOOP1_EXIT # exit
        LOOP1_CONT:
 
        addi t0, t0, 1 # i++
        addi t2, t2, 4 # array ptr += 4
        j LOOP1_BEGIN
    LOOP1_EXIT:
 
    li t0, 800
    add sp, sp, t0 # free stack space
 
    li a0, 17
    ecall
quick_sort: # a[]: a0, L: a1, R: a2
    bge a1, a2, quick_sort_exit
 
    addi sp, sp, -24
 
    sw a0, 0(sp) # a[]
    sw a1, 4(sp) # L
    sw a2, 8(sp) # R
    sw x0, 12(sp) # i
    sw x0, 16(sp) # j
    sw ra, 20(sp) # return addr
 
    # call partition
    addi a3, sp, 12
    addi a4, sp, 16
    jal partition
 
    # call quick_sort 1
    lw t0, 12(sp)
    addi a2, t0, -1
    jal quick_sort
 
    # call quick_sort 2
    lw a1, 16(sp)
    lw a2, 8(sp)
    jal quick_sort
 
    lw ra, 20(sp) # recover return addr
    addi sp, sp, 24
    quick_sort_exit:
ret
 
partition:
# a[]: a0, L: a1, R: a2, *pi: a3, *pj: a4
 
mv t0, a1 # i
mv t1, a1 # j
addi t2, a2, 1 # k
add t3, a1, a2
srli t3, t3, 1
slli t3, t3, 2
add t3, t3, a0
lw t3, 0(t3) # pivot
LOOP2_BEGIN:
    bge t0, t2, LOOP2_EXIT
 
    # fetch a[i] to t4
    mv t4, t0
    slli t4, t4, 2
    add t4, a0, t4
    lw t4, 0(t4)
 
    bge t4, t3, AI_GE_PIVOT # a[i] >= pivot?
    AI_LT_PIVOT: # a[i] < pivot
        # fetch a[j] to t5
        mv t5, t1
        slli t5, t5, 2
        add t5, a0, t5
        lw t5, 0(t5)
 
        # exchange a[i], a[j]
        mv t6, t0
        slli t6, t6, 2
        add t6, a0, t6
        sw t5, 0(t6)
 
        mv t6, t1
        slli t6, t6, 2
        add t6, a0, t6
        sw t4, 0(t6)
        
        addi t0, t0, 1
        addi t1, t1, 1
    j CMP_END
    AI_GE_PIVOT: # a[i] >= pivot
        beq t4, t3,  AI_EQ_PIVOT # a[i] == pivot ?
        # a[i] > pivot
        # fetch a[k] to t5
        addi t2, t2, -1 # --k
        mv t5, t2
        slli t5, t5, 2
        add t5, a0, t5
        lw t5, 0(t5)
 
        # exchange a[i], a[k]
        mv t6, t0
        slli t6, t6, 2
        add t6, a0, t6
        sw t5, 0(t6)
 
        mv t6, t2
        slli t6, t6, 2
        add t6, a0, t6
        sw t4, 0(t6)
 
    j CMP_END
    AI_EQ_PIVOT: # a[i] == pivot
        addi t0, t0, 1
    CMP_END:
    j LOOP2_BEGIN
    LOOP2_EXIT:
    sw t1, 0(a3)
    sw t2, 0(a4)
ret

测试对象是一个从 200 到 1 降序排列的数组，跑一次大概 8 秒左右。本来想开更大的数组以更好地证明算法的有效性，无奈我的代码实在太垃圾，再加上模拟器 debuff，即便是理论上的 $\mathcal{O}(nlogn)$ 也跑得极慢，不过我保证，如果换成朴素快排，那么时间就远远不止 8 秒了。

排序之前：

排序之后：

尽管只是小小的一步，但我感觉自己仿佛改变了世界！这就是所谓的 “成就感”。