Question

我正在尝试学习一些基本的x86 32位汇编编程。因此，在追求这一点时，我决定在汇编中实现快速排序（仅排序整数）。首先我制作了C版的排序功能，然后我制作了一个装配版本。

但是，在将我的程序集版本与我的C版本（在Debian上使用gcc编译）进行比较时，C版本在10000个整数数组上的执行速度提高了10倍以上。

所以我的问题是，是否有人可以就我的快速排序装配例程中可以进行的明显优化提供一些反馈。它纯粹是出于教育目的，我不希望在生成高速代码方面击败编译器制造商，但我很想知道我是否犯了任何妨碍速度的明显错误。

C版：

void myqsort(int* elems, int sidx, int eidx)
{

    if (sidx < eidx)
    {
        int pivot = elems[eidx];
        int i = sidx;
        for (int j = sidx; j < eidx; j++)
        {
            if (elems[j] <= pivot)
            {
                swap(&elems[i], &elems[j]);
                i = i + 1;
            }
        }
        swap(&elems[i], &elems[eidx]);
        myqsort(elems, sidx, i - 1);
        myqsort(elems, i + 1, eidx);
    }
}
void swap(int* a, int* b)
{
    int tmp = *a;
    *a = *b;
    *b = tmp;
}

装配版（NASM）：

;
; void asm_quick_sort(int* elems, int startindex, int endindex)
; Params:
;       elems - pointer to elements to sort - [ebp + 0x8]
;       sid - start index of items - [ebp + 0xC]
;       eid - end index of items - [ebp + 0x10]
asm_quick_sort:

    push ebp
    mov ebp, esp

    push edi
    push esi
    push ebx

    mov eax, dword [ebp + 0xC]  ; store start index,  = i
    mov ebx, dword [ebp + 0x10] ; store end index
    mov esi, dword [ebp + 0x8]  ; store pointer to first element in esi

    cmp eax, ebx
    jnl qsort_done

    mov ecx, eax                        ; ecx = j, = sid
    mov edx, dword [esi + (0x4 * ebx)]  ; pivot element, elems[eid], edx = pivot
qsort_part_loop:
    ; for j = sid; j < eid; j++
    cmp ecx, ebx                    ; if ecx < end index
    jnb qsort_end_part
    ; if elems[j] <= pivot
    cmp edx, dword [esi + (0x4*ecx)]
    jb qsort_cont_loop
    ; do swap, elems[i], elems[j]
    push edx ; save pivot for now
    mov edx, dword [esi + (0x4*ecx)]        ; edx = elems[j]
    mov edi, dword [esi + (0x4*eax)]        ; edi = elems[i]
    mov dword [esi + (0x4*eax)], edx        ; elems[i] = elems[j]
    mov dword [esi + (0x4*ecx)], edi        ; elems[j] = elems[i]
    pop edx ; restore pivot
    ; i++
    add eax, 0x1
qsort_cont_loop:
    add ecx, 0x1
    jmp qsort_part_loop
qsort_end_part:
    ; do swap, elems[i], elems[eid]
    mov edx, dword [esi + (0x4*eax)]        ; edx = elems[i]
    mov edi, dword [esi + (0x4*ebx)]        ; edi = elems[eid]
    mov dword [esi + (0x4*ebx)], edx        ; elems[eidx] = elems[i]
    mov dword [esi + (0x4*eax)], edi        ; elems[i] = elems[eidx]

    ; qsort(elems, sid, i - 1)
    ; qsort(elems, i + 1, eid)
    sub eax, 0x1
    push eax
    push dword [ebp + 0xC]  ; push start idx
    push dword [ebp + 0x8]  ; push elems vector
    call asm_quick_sort
    add esp, 0x8
    pop eax
    add eax, 0x1
    push dword [ebp + 0x10] ; push end idx
    push eax
    push dword [ebp + 0x8]  ; push elems vector
    call asm_quick_sort
    add esp, 0xC


qsort_done:
    pop ebx
    pop esi
    pop edi

    mov esp, ebp
    pop ebp

    ret

我从C调用汇编程序，我使用clock（）来计算例程。

修改在纠正我的伙伴stackoverflowers指出的错误后，性能上的差异不再是问题。

Answer 1

您可以仅使用1个额外的寄存器EDI来优化元素的交换，而无需在EDX中推送和弹出透视值：

mov  edi, dword [esi + (0x4*eax)]   ; edi = elems[i]
xchg dword [esi + (0x4*ecx)], edi   ; elems[j] = edi, edi = elems[j]
mov  dword [esi + (0x4*eax)], edi   ; elems[i] = edi

第二次交换也可以缩短：

mov  edi, dword [esi + (0x4*ebx)]   ; edi = elems[eid]
xchg dword [esi + (0x4*eax)], edi   ; elems[i] = edi, edi = elems[i]
mov  dword [esi + (0x4*ebx)], edi   ; elems[eid] = edi

您可以安全地从epilog代码中删除mov esp, ebp，因为它是多余的。如果那些3 pop进展顺利，你就已经知道堆栈指针具有正确的值。

qsort_done:
  pop ebx
  pop esi
  pop edi
  mov esp, ebp    <-- This is useless!
  pop ebp
  ret

Answer 2

您的程序集排序实现中存在错误，在您解决之前，速度比较是无用的。问题是递归调用：

    myqsort(elems, sidx, i - 1);

虽然不一定i不是sidx，但这可能会将小于sidx的值传递给函数，包括-1 sidx这是在你的C实现中处理的：

if (sidx < eidx)

但是在你的汇编版本中：

cmp eax, ebx
jae qsort_done

这是 unsigned 比较分支指令！您应该使用jge。由于这个问题，我看到了一个段错误。修复后，根据我的快速测试（使用-O3编译），两种实现的性能似乎大致相同。我使用了以下测试驱动程序：

#include <stdlib.h>
#include <stdio.h>

void myqsort(int * elems, int sidx, int eidx);

#define SIZE 100000

int main(int argc, char **argv)
{
    int * elems = malloc(SIZE * sizeof(int));

    for (int j = 0; j < 1000; j++) {

        for (int i = 0; i < SIZE; i++) {
            elems[i] = rand();
        }

        myqsort(elems, 0, SIZE - 1);
    }
    return 0;
}

使用C版本，运行时间约为5.854秒。使用汇编版本，它是5.829秒（即略快）。

适用于x86 32位汇编的快速排序

2 个答案: