-         

Ergebnis 1 bis 3 von 3

Thema: for then -> Assembler

  1. #1

    for then -> Assembler

    Anzeige

    SMARTPHONES & TABLETS-bis zu 77% RABATT-Kostenlose Lieferung-Aktuell | Cool | Unentbehrlich
    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

  2. #2
    Erfahrener Benutzer Robotik Einstein Avatar von SprinterSB
    Registriert seit
    09.06.2005
    Ort
    An der Saar
    Beiträge
    2.801
    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) */
    Disclaimer: none. Sue me.

  3. #3
    Danke für die Antwort.

    Wie mein Compiler arbeitet weiss ich leider nicht.
    Ist auch nicht für Mikrocontroller, sondern ein Grafikkartenshader. 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

Berechtigungen

  • Neue Themen erstellen: Nein
  • Themen beantworten: Nein
  • Anhänge hochladen: Nein
  • Beiträge bearbeiten: Nein
  •