13、数据结构与高性能汇编编程

数据结构与高性能汇编编程

1. 二叉树相关操作

1.1 二叉树节点和树结构

二叉树的节点包含一个整数值和两个指针。节点结构定义如下：

struc 
node 
n_value resq 1 
n_left resq 1 
n_right resq 1 
align 8 
ends true

为了避免树的根节点发生变化带来的问题，我们将根节点存储在一个结构中，同时该结构还记录了树中节点的数量。树结构定义如下：

struc 
tree 
t_count resq 1 
t_root resq 1 
align 8 
ends true

1.2 创建空树

new_tree 函数用于为树结构分配内存，并将新树的节点计数和根节点初始化为 0。代码如下：

new_tree : 
push rbp 
mov rbp, rsp 
mov rdi, tree size 
call malloc 
xor edi, edi 
mov [rax+t_root], rdi 
mov [rax+t_count], rdi 
leave 
ret

1.3 在树中查找键

在二叉搜索树中查找键的过程是从根节点开始，将节点的键与要查找的键进行比较。如果匹配则查找成功；如果目标键小于节点的键，则转向左子节点；如果目标键大于节点的键，则转向右子节点。重复这个过程，直到找到匹配的键或遇到 NULL 指针。代码如下：

find : 
. more 
. goleft : 
p = find ( t, n ) ;  
p = 0 if not found 
push rbp 
mov rbp, rsp 
mov rdi, [rdi +t_root] 
xor eax, eax 
cmp rdi, 0 
je . done 
cmp rsi, [rdi +n_value] 
jl . goleft 
jg . goright 
mov rax, rsi 
jmp . done 
mov rdi, [rdi +n_left] 
jmp . more 
. goright : 
mov rdi, [rdi+n_right] 
jmp .more 
. done 
leave 
ret

1.4 向树中插入键

插入键的第一步是使用 find 函数检查键是否已经存在。如果存在，则不进行插入；如果不存在，则分配一个新的树节点，将其值设置为新键的值，并将左右子节点指针设置为 NULL 。然后找到插入位置。如果树为空，则将新节点设置为根节点；如果树不为空，则从根节点开始比较，根据键的大小决定插入到左子树还是右子树。代码如下：

insert ( t, n ) ;  
insert: 
. n equ 0 
. t equ 8 
push rbp 
mov rbp, rsp 
sub rsp, 16 
mov [rsp+ . t], rdi 
mov [rsp+ . n], rsi 
call find 
cmp rax, 0 
jne . done 
mov rdi, node_size 
call malloc 
mov rsi, [rsp+ . n] 
mov [rax+n_value], rsi 
xor edi, edi 
mov [rax+n_left], rdi 
mov [rax+n_right], rdi 
mov rdx, [rsp+ . t] 
mov rdi, [rdx+t_count] 
cmp rdi, 0 
jne . findparent 
inc qword [rdx+t_count] 
mov [rdx+t_root], rax 
jmp . done 
. findparent : 
mov rdx, [rdx+t_root] 
. repeatfind: 
cmp rsi, [rdx+n_value] 
jl . goleft 
mov r8, rdx 
mov rdx, [r8+n_right] 
cmp rdx, 0 
jne . repeatfind 
mov [r8+n_right], rax 
jmp . done 
. goleft : 
mov r8, rdx 
mov rdx, [r8+n_left] 
cmp rdx, 0 
jne . repeatfind 
mov [r8+n_left], rax 
. done 
leave 
ret

1.5 按顺序打印键

使用递归的方法按顺序打印二叉树的键。先打印左子树的键，再打印根节点的键，最后打印右子树的键。代码如下：

rec_print : 
. t equ 0 
. print 
push rbp 
mov rbp, rsp 
sub rsp, 16 
cmp rdi, 0 
je . done 
mov [rsp+ . t], rdi 
mov rdi, [rdi+n_left] 
call rec_print 
mov rdi, [rsp+ . t] 
mov rsi, [rdi+n_value] 
segment .data 
db "%ld ", 0 
segment .text 
lea rdi, [. print] 
call printf 
mov rdi, [rsp+ . t] 
mov rdi, [rdi+n_right] 
call rec_print 
. done 
leave 
ret 
print (t) ; 
print : 
push rbp 
mov rbp, rsp 
mov rdi, [rdi +t_root] 
call rec_print 
segment .data 
. print 
db 0x0a, 0 
segment .text 
lea rdi, [. print] 
call printf 
leave 
ret

2. 高性能汇编编程策略

2.1 通用优化策略

为了实现高性能汇编编程，有许多可能的策略，其中一些策略被现代编译器广泛应用，部分策略也可用于高级语言。具体策略如下：
- 使用更好的算法
- 使用 C 或 C++
- 有效利用缓存
- 消除公共子表达式
- 强度削弱
- 高效使用寄存器
- 减少分支
- 将循环转换为底部分支
- 展开循环
- 合并循环
- 拆分循环
- 交换循环
- 将循环不变代码移到循环外部
- 消除递归
- 消除栈帧
- 内联函数
- 消除依赖以实现超标量执行
- 使用专用指令

2.2 使用更好的算法

使用更好的算法是最重要的优化策略。例如，使用 qsort 函数比花费大量时间调整 shell sort 更能提高性能。如果要实现字典，可以考虑使用哈希表或红黑树。哈希表查找键的期望时间复杂度为 $O(1)$，红黑树的查找时间复杂度为 $O(\lg n)$，且红黑树可以保证有序访问键。

2.3 使用 C 或 C++

使用 C 或 C++ 有以下好处：
- 对于应用程序中不需要优化的部分，使用 C 或 C++ 可以节省时间，并且可能获得相同的性能。
- 编写 C 版本的代码并与自己的汇编代码进行比较，以确定是否比编译器更高效。
- 使用 gcc 的 -S 选项生成汇编语言文件，学习编译器的优化技巧。

2.4 有效利用缓存

现代 CPU 的处理速度远高于主内存的访问速度，因此需要使用多级缓存来保持 CPU 的指令流。例如，在矩阵乘法中，将矩阵分块可以使数据更好地适应缓存，从而提高性能。

2.5 消除公共子表达式

优化编译器通常会执行公共子表达式消除。为了超越编译器，我们也需要进行相同的操作。有时可能难以找到所有的公共子表达式，此时可以研究编译器生成的代码。

2.6 强度削弱

强度削弱是指使用更简单的数学技术来获得结果。例如，计算 $x^3$ 可以使用 x * x * x 而不是 pow 函数；计算 $x^4$ 可以分阶段进行。对于整数的乘除 2 的幂运算，可以使用移位操作。

2.7 高效使用寄存器

将常用的值存储在寄存器中通常可以提高性能，但有时使用栈存储一些值也能获得较好的效果，需要通过测试来确定。

2.8 减少分支

现代 CPU 会进行分支预测，但预测错误会导致流水线停顿。因此，减少分支可以提高性能。可以学习编译器生成的代码，了解如何重新排列汇编代码以减少分支。

2.9 将循环转换为底部分支

将 while 循环转换为 do-while 循环可以将条件分支移到循环底部，减少不必要的跳转。示例如下：

// 原始 for 循环
for ( i = 0; i < n; i++ ) {
    x [i] = a [i] + b [i];
}

// 转换后的 do-while 循环
if ( n > 0 ) {
    i = 0;
    do {
        x [i] = a [i] + b [i];
        i++;
    } while ( i < n );
}

2.10 展开循环

展开循环可以减少循环控制指令，增加执行实际工作的指令，并且使 CPU 有更多指令填充流水线。例如，将一个简单的数组求和循环展开 4 次后，性能有明显提升。简单版本代码如下：

segment .text 
global add_array 
add_array : 
xor eax, eax 
.add_words : 
add rax, [rdi] 
add rdi, 8 
dec rsi 
jg .add_words 
ret

展开 4 次的版本代码如下：

segment .text 
global add_array 
add_array : 
push r15 
push r14 
push r13 
push r12 
push rbp 
push rbx 
xor eax, eax 
mov rbx, rax 
mov rex, rax 
mov rdx, rax 
.add words : 
add rax, [rdi] 
add rbx, [rdi+8] 
add rex, [rdi+16] 
add rdx, [rdi+24] 
add rdi, 32 
sub rsi, 4 
jg .add_words 
add rex, rdx 
add rax, rbx 
add rax, rex 
pop rbx 
pop rbp 
pop r12 
pop r13 
pop r14 
pop r15 
ret

通过上述操作和策略，可以在汇编编程中实现更好的性能。下面是一个简单的流程图，展示了在树中查找键的过程：

graph TD;
    A[开始] --> B[从根节点开始];
    B --> C{键是否匹配};
    C -- 是 --> D[查找成功];
    C -- 否 --> E{目标键 < 节点键};
    E -- 是 --> F[转向左子节点];
    E -- 否 --> G[转向右子节点];
    F --> H{是否为 NULL};
    H -- 是 --> I[查找失败];
    H -- 否 --> C;
    G --> J{是否为 NULL};
    J -- 是 --> I;
    J -- 否 --> C;

同时，为了更清晰地展示通用优化策略，我们列出如下表格：
|策略|描述|
|----|----|
|使用更好的算法|选择更高效的算法来解决问题|
|使用 C 或 C++|利用编译器的优化能力|
|有效利用缓存|提高数据访问速度|
|消除公共子表达式|避免重复计算|
|强度削弱|使用更简单的数学运算|
|高效使用寄存器|减少内存访问|
|减少分支|避免流水线停顿|
|将循环转换为底部分支|优化循环结构|
|展开循环|减少循环控制指令|
|合并循环|减少循环次数|
|拆分循环|提高并行性|
|交换循环|优化内存访问模式|
|将循环不变代码移到循环外部|减少重复计算|
|消除递归|避免栈溢出和性能开销|
|消除栈帧|减少栈操作|
|内联函数|减少函数调用开销|
|消除依赖以实现超标量执行|提高 CPU 并行执行能力|
|使用专用指令|利用 CPU 的特殊功能|

数据结构与高性能汇编编程

3. 相关练习

为了更好地掌握上述数据结构和优化策略，下面给出一些相关练习及思路。

3.1 单链表实现字符串栈

修改单链表代码以实现字符串栈。可以使用 C 语言的 strdup 函数复制插入的字符串。主程序创建一个栈，进入循环读取字符串。如果输入的字符串为 “pop”，则弹出栈顶元素并打印；如果为 “print”，则打印栈的内容；否则将字符串压入栈中。当 scanf 或 fgets 无法读取字符串时，程序退出。

操作步骤如下：
1. 定义单链表节点结构，包含字符串指针和指向下一个节点的指针。
2. 实现栈的基本操作，如入栈、出栈和打印栈内容。
3. 在主程序中，使用循环读取输入字符串，并根据输入执行相应操作。

3.2 双链表实现字符串队列

修改双链表代码以实现字符串队列。主程序读取字符串，直到无法读取为止。如果输入的字符串为 “dequeue”，则出队并打印最早入队的字符串；如果为 “print”，则打印队列的内容；否则将字符串添加到队列末尾。当 scanf 或 fgets 无法读取字符串时，程序退出。

操作步骤如下：
1. 定义双链表节点结构，包含字符串指针、指向前一个节点的指针和指向后一个节点的指针。
2. 实现队列的基本操作，如入队、出队和打印队列内容。
3. 在主程序中，使用循环读取输入字符串，并根据输入执行相应操作。

3.3 哈希表存储字符串和整数

修改哈希表代码，实现一个存储字符串和整数的哈希表。字符串作为键，整数作为关联值。主程序使用 fgets 读取行，再使用 sscanf 解析字符串和数字。如果 sscanf 返回 1，表示只有字符串，在哈希表中查找该字符串并打印其值，若不存在则打印错误信息；如果 sscanf 返回 2，表示有字符串和数字，将字符串添加到哈希表或更新其值。当 fgets 无法读取字符串时，程序退出。

操作步骤如下：
1. 定义哈希表节点结构，包含字符串键、整数值和指向下一个节点的指针。
2. 实现哈希函数，将字符串映射到哈希表的索引。
3. 实现哈希表的基本操作，如插入、查找和更新。
4. 在主程序中，使用循环读取输入行，解析字符串和数字，并执行相应操作。

3.4 字符串二叉树实现文本排序

实现一个字符串二叉树，使用 fgets 读取文本文件，然后按字母顺序打印文本行。

操作步骤如下：
1. 定义二叉树节点结构，包含字符串值和左右子节点指针。
2. 实现二叉树的插入操作，将字符串插入到合适的位置。
3. 实现按顺序打印二叉树节点的功能。
4. 在主程序中，打开文本文件，使用 fgets 读取每一行，并插入到二叉树中，最后按顺序打印二叉树。

下面是一个简单的流程图，展示了哈希表插入或更新操作的过程：

graph TD;
    A[开始] --> B[读取输入行];
    B --> C[使用 sscanf 解析];
    C --> D{返回值是否为 2};
    D -- 是 --> E[获取字符串和数字];
    D -- 否 --> F[仅获取字符串];
    E --> G[计算哈希值];
    F --> G;
    G --> H[查找哈希表位置];
    H --> I{键是否存在};
    I -- 是 --> J[更新值];
    I -- 否 --> K[插入新节点];
    J --> L[结束];
    K --> L;

同时，为了更清晰地展示练习的相关信息，我们列出如下表格：
|练习|描述|操作步骤|
|----|----|----|
|单链表实现字符串栈|使用单链表实现字符串栈，支持入栈、出栈和打印操作|定义节点结构，实现栈操作，主程序读取输入并执行相应操作|
|双链表实现字符串队列|使用双链表实现字符串队列，支持入队、出队和打印操作|定义节点结构，实现队列操作，主程序读取输入并执行相应操作|
|哈希表存储字符串和整数|实现存储字符串和整数的哈希表，支持插入、查找和更新操作|定义节点结构，实现哈希函数和哈希表操作，主程序读取输入并执行相应操作|
|字符串二叉树实现文本排序|实现字符串二叉树，按字母顺序打印文本行|定义节点结构，实现插入和打印操作，主程序读取文件并插入节点，最后打印|

通过完成这些练习，可以加深对数据结构和高性能汇编编程策略的理解和应用能力。在实际编程中，需要根据具体问题选择合适的数据结构和优化策略，以达到最佳的性能。