Помогите улучшить простую функцию сборки

Question

Я только что передал эту функцию в задании. Это сделано (следовательно, нет домашней метки). Но я хотел бы посмотреть, как это можно улучшить.

По сути, функция суммирует квадраты всех целых чисел от 1 до заданного числа, используя следующую формулу:

n(n+1)(2n+1)/6

Где n - максимальное число.

Приведенная ниже функция предназначена для улавливания любого переполнения и возврата 0 в случае возникновения.

UInt32 sumSquares(const UInt32 number)
{
    int result = 0;
    __asm
    {
        mov eax, number  //move number in eax
        mov edx, 2       //move 2 in edx
        mul edx          //multiply (2n)
        jo end           //jump to end if overflow
        add eax, 1       //addition (2n+1)
        jo end           //jump to end if overflow
        mov ecx, eax     //move (2n+1) in ecx

        mov ebx, number  //move number in ebx
        add ebx, 1       //addition (n+1)
        jo end           //jump to end if overflow

        mov eax, number //move number in eax for multiplication
        mul ebx         //multiply n(n+1)
        jo end          //jump to end if overflow
        mul ecx         //multiply n(n+1)(2n+1)
        jo end          //jump to end if overflow
        mov ebx, 6      //move 6 in ebx
        div ebx         //divide by 6, the result will be in eax

        mov result, eax //move eax in result

end:
    }

    return result;
}

По сути, я хочу знать, что я могу улучшить там. С точки зрения лучших практик в основном. Одна вещь звучит очевидным: более разумная проверка переполнения (с единственной проверкой того, какой максимальный вход вызовет переполнение).

Answer 1

    mov eax, number  //move number in eax
    mov ecx, eax     //dup in ecx
    mul ecx          //multiply (n*n)
    jo end           //jump to end if overflow
    add eax, ecx     //addition (n*n+n); can't overflow
    add ecx, ecx     //addition (2n); can't overflow
    add ecx, 1       //addition (2n+1); can't overflow
    mul ecx          //multiply (n*n+n)(2n+1)
    jo end           //jump to end if overflow
    mov ecx, 6       //move 6 in ebx
    div ecx          //divide by 6, the result will be in eax

    mov result, eax //move eax in result

Снижение силы: добавьте вместо умножения.

По результатам анализа, меньше проверок на переполнение (вы можете сделать лучше, как вы описали).

Храните значения в регистрах вместо возврата к аргументу в стеке.

Тщательно выбирайте регистры, чтобы значения, которые можно использовать повторно, не перезаписывались.

Answer 2

UInt32 sumSquares(const UInt32 number)
{
  __asm
  {
    mov eax, number     // n
    cmd eax, MAX_VALUE
    jg  bad_value

    lea ebx, [eax+1]    // n + 1
    lea ecx, [2*eax+1]  // 2n + 1

    mul ebx
    mul ecx

    shr eax, 1          // divide by 2
    mov ebx, 2863311531 // inverse of 3
    mul ebx             // divide by 3

    ret

    bad_value:
    xor eax, eax        // return 0
    ret
  }
}

http://blogs.msdn.com/devdev/archive/2005/12/12/502980.aspx

Spara

Answer 3

mov eax, number    ; = n
cmp eax, 0x928     ; cannot handle n >= 0x928
jnc end 
shl eax, 1         ; = n(2)
add eax, 3         ; = n(2)+3
mov ebx, number
mul ebx            ; = n(n(2)+3)
add eax, 1         ; = n(n(2)+3)+1
mov ebx, number
mul ebx            ; = n(n(n(2)+3)+1) = n(n+1)(2n+1)
mov ebx, 6
div ebx
mov result, eax

Вместо того, чтобы проверять переполнение, это решение проверяет ввод по известному максимальному значению, которое может обработать функция.Обратите внимание, что последнее умножение может быть переполнено, и оно будет переполнено для любого входа number больше 0x509.Сравнение с известным значением, а не проверка переполнения позволяет функции обрабатывать почти вдвое больше входных значений.Фактически, функция способна обрабатывать каждый вход, результат которого находится в пределах 32 бит.