Блог

  mov eax,0
 mov ecx,100 

loop2_start: mov eax,ecx
             add eax,ecx 
             imul eax,eax  ;To act as n^2
             jle loop2_start

loop2_end: call print_int
           call print_nl
  

Я пытаюсь найти сумму всех квадратов от 1 до 100. Когда я печатаю это, это дает мне 40000, когда ответ должен быть 338350. Что я должен изменить, чтобы заставить его работать? Возможно, моя инструкция перехода?

Давайте начнем с некоторой математики.

Для положительных значений n , если:

 lastSquare = n*n
  

Затем:

 nextSquare = (n 1)*(n 1)
           = (n * n)   (n * 1)   (1 * n)   1
           = (n * n)   2 * n   1
           = lastSquare   2 * n   1
  

Другими словами, (используя псевдокод, подобный C), вы можете сделать:

     square = 0;
    sum = 0;
    for(n = 1-1; n < 100-1; n  ) {
        square = square   2 * n   1;
        sum = sum   square;
    }
  

Для сборки 80×86 square = square 2 * n 1 это может быть выполнено с помощью одной быстрой инструкции — например lea ebx,[ebx ecx*2 1] .

Это дает что-то вроде (синтаксис NASM, непроверенный):

 ; Loop preperation

    xor ebx,ebx           ;ebx = square = 0
    xor eax,eax           ;eax = sum = 0
    xor ecx,ecx           ;ecx = n = 1-1

; Loop

.next:
    lea ebx,[ebx ecx*2 1] ;ebx = square   2 * n   1
    add eax,ebx           ;eax = sum   square

; Loop end

    inc ecx
    cmp ecx,100-1
    jb .next
  

Однако; середина цикла мала по сравнению с накладными расходами цикла, поэтому было бы интересно немного развернуть цикл, чтобы уменьшить накладные расходы цикла. 99 нечетно, но кратно 3, поэтому:

 ; Loop preperation

    xor ebx,ebx           ;ebx = square = 0
    xor eax,eax           ;eax = sum = 0
    xor ecx,ecx           ;ecx = n = 1-1

; Loop

.next:
    lea ebx,[ebx ecx*2 1]   ;ebx = square   2 * n   1
    add eax,ebx             ;eax = sum   square
    lea ebx,[ebx ecx*2 2 1] ;ebx = square   2 * (n 1)   1
    add eax,ebx             ;eax = sum   square
    lea ebx,[ebx ecx*2 4 1] ;ebx = square   2 * (n 2)   1
    add eax,ebx             ;eax = sum   square

; Loop end

    add ecx,3
    cmp ecx,100-1
    jb .next
  

Это позволяет вам использовать математику для большего мошенничества! В частности:

 nextSquare = (n 1)*(n 1)
           = (n * n)   (n * 1)   (1 * n)   1
           = (n * n)   2 * n   1
           = lastSquare   2 * n   1

nextNextSquare = (n 2)*(n 2)
               = (n * n)   (n * 2)   (2 * n)   2*2
               = (n * n)   4 * n   4
               = lastSquare   4 * n   4

nextNextNextSquare = (n 3)*(n 3)
                   = (n * n)   (n * 3)   (3 * n)   3*3
                   = (n * n)   6 * n   9
                   = lastSquare   6 * n   9

nextAddend = nextSquare    nextNextSquare   nextNextNextSquare
           = lastSquare   2 * n   1   lastSquare   4 * n   4   lastSquare   6 * n   9
           = 3 * lastSquare   12 * n   14
           = 3 * (lastSquare   4 * n)   14
  

Это приводит к чему-то вроде (синтаксис NASM, непроверенный):

 ; Loop preperation

    xor ebx,ebx           ;ebx = square = 0
    xor eax,eax           ;eax = sum = 0
    xor ecx,ecx           ;ecx = n = 1-1

; Loop

.next:
    lea edx,[ebx ecx*4]      ;edx = square   4 * n
    lea edx,[edx*2 edx 14]   ;edx = 3 * (square   4 * n)   14
    add eax,edx              ;eax = sum   nextSquare    nextNextSquare   nextNextNextSquare
    lea edx,[ecx*2 ecx]      ;edx = 2*n
    lea ebx,[ebx 2*edx 9]    ;ebx = lastSquare   6 * n   9 = nextNextNextSquare


; Loop end

    add ecx,3
    cmp ecx,100-1
    jb .next
  

Конечно, разворачивая цикл больше, вы больше обманываете; но если вы продолжаете это делать и оптимизируете, вы в конечном итоге «полностью развернуты» (больше нет цикла), где код становится одной mov eax,precalculated_constant инструкцией «».