for then -> Assembler

Hallo Zusammen,

leider kenne ich mich nicht mit Assembler aus, hätte jedoch eine Frage dazu.
-Wenn ich eine For Then Schleife mache die in Assembler umcompiliert wird, ist es dann schneller, wenn ich die Schritte alle einzeln aufschreibe oder macht der Compiler das sowieso?

Also anstatt:
Ar = Array ((5,6)(3,4));

For i=0; i<2; i++ Then
For j=0; i<2; j++ Then
X= X+Ar[i][j];
Next
Next


So:
X=X+5;
X=X+6;
X=X+3;
X=X+4;

Das ist jetzt natürlich verkleinerter Code ;) So exemplarisch, die eigentliche Matrix ist 9 oder 25fach. Ich frage mich nämlich, ob der Schreibaufwand gerechtfertigt wäre.

-Wieviel Assemblerschritte würde ich in etwa sparen?

Ciao FuRanKu

Dis ist abhängig von deinem Compiler und welche Optimierungsstrategien er anwendet, sowie wieviel Wissen über dein Programm du ihm mitgibst...
Um hier guten Code zu machen braucht dein Compiler mindestens folgende Optimierungsstrategien:
Loop unrolling, strength reduction, common subexbression elimination.


Hier mal als Standard-C:

Code:

---

#define DIMX 2
#define DIMY 2

char array[DIMX][DIMY] =
{
        {5, 6},
        {3, 4}
};

char foo (char a[DIMX][DIMY])
{
        char sum = 0;
        unsigned char x, y;

        for (x=0; x < DIMX; x++)
                for (y=0; y < DIMY; y++)
                        sum += a[x][y];
               
        return sum;
}       

int main()
{
        return foo (array);
}

---

Als Compiler nehme ich einen avr-gcc (C --> AVR-Assembler)
Ich rechne dabei der Einfachheit halber mit 8-Bit Werten, sonst sieht man garnix mehr (AVR ist eine 8-Bit MCU). Angegeben sind die Optimierungsstufen.

-O0

Code:

---

foo:
/* prologue: frame size=5 */
        push r28
        push r29
        in r28,__SP_L__
        in r29,__SP_H__
        sbiw r28,5
        in __tmp_reg__,__SREG__
        cli
        out __SP_H__,r29
        out __SREG__,__tmp_reg__
        out __SP_L__,r28
/* prologue end (size=10) */
        std Y+1,r24        ;  a, a
        std Y+2,r25        ;  a, a
        std Y+3,__zero_reg__        ;  sum,
        std Y+4,__zero_reg__        ;  x,
.L2:
        ldd r24,Y+4        ;  x, x
        cpi r24,lo8(2)        ;  x,
        brsh .L3        ; ,
        std Y+5,__zero_reg__        ;  y,
.L5:
        ldd r24,Y+5        ;  y, y
        cpi r24,lo8(2)        ;  y,
        brsh .L4        ; ,
        ldd r24,Y+4        ;  x, x
        mov r18,r24        ;  x, x
        clr r19        ;  x
        ldd r24,Y+5        ;  y, y
        mov r20,r24        ;  y, y
        clr r21        ;  y
        movw r24,r18        ;  x, x
        add r18,r24        ;  tmp49, x
        adc r19,r25        ;  tmp49, x
        ldd r24,Y+1        ;  a, a
        ldd r25,Y+2        ;  a, a
        add r24,r18        ;  tmp50, tmp49
        adc r25,r19        ;  tmp50, tmp49
        movw r30,r24        ;  tmp52, tmp50
        add r30,r20        ;  tmp52, y
        adc r31,r21        ;  tmp52, y
        ldd r25,Y+3        ;  sum, sum
        ld r24,Z        ;  tmp54,
        add r24,r25        ;  tmp55, sum
        std Y+3,r24        ;  sum, tmp55
        ldd r24,Y+5        ;  y, y
        subi r24,lo8(-(1))        ;  tmp57,
        std Y+5,r24        ;  y, tmp57
        rjmp .L5        ;
.L4:
        ldd r24,Y+4        ;  x, x
        subi r24,lo8(-(1))        ;  tmp59,
        std Y+4,r24        ;  x, tmp59
        rjmp .L2        ;
.L3:
        ldd r24,Y+3        ;  sum, sum
        clr r25        ;  sum
        sbrc r24,7        ;  sum
        com r25        ;  sum
/* epilogue: frame size=5 */
        adiw r28,5
        in __tmp_reg__,__SREG__
        cli
        out __SP_H__,r29
        out __SREG__,__tmp_reg__
        out __SP_L__,r28
        pop r29
        pop r28
        ret
/* epilogue end (size=9) */
/* function foo size 62 (43) */

---

-Os

Code:

---

foo:
/* prologue: frame size=0 */
/* prologue end (size=0) */
        movw r22,r24        ;  a, a
        ldi r20,lo8(0)        ;  sum,
        ldi r21,lo8(1)        ;  x,
        ldi r18,lo8(0)        ;  tmp78,
        ldi r19,hi8(0)        ;  tmp78,
.L9:
        movw r30,r18        ;  tmp55, tmp78
        add r30,r22        ;  tmp55, a
        adc r31,r23        ;  tmp55, a
        ld r24,Z+        ;  tmp65,
        add r20,r24        ;  sum, tmp65
        ld r24,Z        ;  tmp70,
        add r20,r24        ;  sum, tmp70
        subi r21,lo8(-(-1))        ;  x,
        subi r18,lo8(-(2))        ;  tmp78,
        sbci r19,hi8(-(2))        ;  tmp78,
        sbrs r21,7        ;  x,
        rjmp .L9        ;
        mov r24,r20        ;  <result>, sum
        clr r25        ;  <result>
        sbrc r24,7        ;  <result>
        com r25        ;  <result>
/* epilogue: frame size=0 */
        ret
/* epilogue end (size=1) */
/* function foo size 22 (21) */

---

-O2 -funroll-loops

Code:

---

foo:
/* prologue: frame size=0 */
/* prologue end (size=0) */
        movw r30,r24        ;  a, a
        ld r24,Z        ;  sum,* a
        ldd r25,Z+1        ;  tmp71,
        add r24,r25        ;  sum, tmp71
        ldd r25,Z+2        ;  tmp66,
        add r24,r25        ;  sum, tmp66
        ldd r25,Z+3        ;  tmp71,
        add r24,r25        ;  sum, tmp71
        clr r25        ;  <result>
        sbrc r24,7        ;  <result>
        com r25        ;  <result>
/* epilogue: frame size=0 */
        ret
/* epilogue end (size=1) */
/* function foo size 12 (11) */

---

Danke für die Antwort.

Wie mein Compiler arbeitet weiss ich leider nicht.
Ist auch nicht für Mikrocontroller, sondern ein Grafikkartenshader. :-b Wußte allerdings nicht wo ich sonst Assemblerprofis finde.

Ich denke ich werde mir die Mühe machen, das alles in Einzelschritte umzuschreiben, denn das erste Beispiel scheint ja einen ziemlichen Overhead zu haben.

Ciao FuRanKu