Aufgabenbereich Assembler - Projekt 1.30
 
• Anwenderdokumentation
• Entwicklerdokumentation
• Quellcode C-Rahmenprogramm

Die Subroutine DSWAP muss wie in der Aufgabenstellung verlangt mit (N, DX, INCX, DY, INCY) aufgerufen werden.N ist eine Integer Zahl, die die Anzahl der Vertauschungen bestimmt. Dabei muss man darauf achten, dass N*INCX und N*INCY nicht größer als die tatsächlich vorhandenen Vektor-Längen sind.DX und DY sind die Pointer auf das erste Element des Vektors X bzw. Y.INCX und INCY sind Integer Zahlen, die die Schrittweite beim Vertauschen durch die jeweiligen Vektoren bestimmen. Wichtig ist, dass diese größer als 0 sind, da sonst falsche Speicher Bereiche getauscht werden, oder ein Segmentation Fault erzeugt wird.

Die Subroutine vertauscht die Vektorkomponenten direkt im Speicher und hat somit keinen Rückgabewert. Nach der Ausführung liegen die Veränderten Vektoren an der Stelle der Alten. Will man diese also erhalten so muss man sie vor dem Aufruf von DSWAP unbedingt sichern.

Vertauscht werden genau N Vektorkomponenten. Wenn INCX und INCY beide 1 sind, so werden alle N Vektorkomponenten miteinander vertauscht. Sind INCX und INCY nicht 1, so muss man darauf achten, dass man die richtigen Werte wählt, sonst könnte man unerwartete Ergebnisse erhalten.

Zur besseren Verständlichkeit (siehe auch Testläufe für Details):

1. N=2, INCX =1 und  INCY=2 meint, dass die 1. Komponente von X mit der 2. von Y vertauscht wird, als auch die 2. X-Komponente mit der 4. Y-Komponente vertauscht wird.
2. Sind sowohl INCX als auch INCY gleich 2, so werden jeweils in 2er Schritten die Komponenten der Vektoren vertauscht. Also die 2. miteinander, die 4. miteinander, die 6. miteinander...
3. Ist INCX=2 und INCY=1 so werden die Komponenten analog zu 1. vertauscht, nur mit vertauschten X und Y Vektoren.

Erklärungen zu den einzelnen Schritten siehe Anmerkungen im Programm.

global _dswap     _dswap:         push ebp                        ; ebp auf Stack retten da er im c-Programm noch benötigt wird         mov ebp, esp                    ; Stackpointer in ebp laden         push edi                        ; Register sichern         push esi         push ebx         push eax         push ecx         push edx         mov esi, [ebp+8]                ; n nach esi laden         cmp esi, 0                      ; bei n <=0 soll nichts gemacht werden         jle ende                        ; also Sprung nach ende         mov ecx, [ebp+12]               ; Vektor_x* nach ecx laden         sub ecx, 8                      ; auf Komponente -1 setzen weil in der Schleife zuerst 8                                         ; addiert wird und es somit wieder auf die 1. Komponente setzt         mov edx, [ebp+20]               ; Vektor_y* nach edx laden         sub edx, 8         mov edi, [ebp+16]               ; incx nach edi laden     schleife:         mov eax, [ebp+24]               ; incy nach eax laden         lea ecx, [ecx+edi*8]            ; Startadresse der zu vertauschenden x-Komponente nach ecx         lea edx, [edx+eax*8]            ; Startadresse der zu vertauschenden y-Komponente nach edx                                         ; Die Vertauschungsoperation: i meint dabei den aktuellen                                         ; Schleifendurchlauf, der von 0 bis n geht:         mov eax, [ecx]                  ; Vektor_x[i*incx] nach eax         mov ebx, [edx]                  ; Vektor_y[i*incy] nach ebx         mov [edx], eax                  ; eax nach Vektor_y[i*incy]         mov [ecx], ebx                  ; ebx nach Vektor_x[i*incx]         add ecx, 4                      ; mit den restlichen 32 bit des Doubles genauso verfahren         add edx, 4         mov ebx, [edx]         mov eax, [ecx]         mov [edx], eax         mov [ecx], ebx         sub ecx, 4                      ;wieder auf die Startadresse setzten, damit die Schleife weiterrechnen kann         sub edx, 4         dec esi                         ; n--         jnz schleife                    ; bei n=0 Abbruch der Schleife     ende:         pop edx                         ; Zurückladen der gesicherten Register         pop ecx         pop eax         pop ebx         pop esi         pop edi         leave                           ; Zurückladen des gesicherten Basepointers und wiederherstellen des                                         ; Stackpointers         ret                             ; Zurücksprung ins C-Programm





Stackaufbau, vor den Pushs zur Registersicherung:




...	Wachsender Stack: hier kommen dann alle gesicherten Register hin
Gesicherter EBP	EBP/SP
Return Adresse	EBP+4
N	EBP+8
Startadresse von Vektor X	EBP+12
INCX	EBP+16
Startadresse von Vektor Y	EBP+20
INCY	EBP+24
...	Weitere Lokale Variablen des C-Programms





Das Programm in Pseudocode funktioniert in etwa so:



begin

i=1;

while (N>0) do begin

	temp = vector_x[(i*INCX)-1];
	vector_x[(i*INCX)-1] = vector_y[(i*INCY)-1];
	vector_y[(i*INCY)-1] = temp;
	i++;
	N--;
	end;
end;

Ein Problem wie es bei der Assembler-Programmierung häufig auftritt war die Begrenztheit der Register. Gelöst wurde es, indem zu beginn der Schleife immer wieder INCY geholt wird und somit EAX nach der Adressberechnung wieder zur Zwischenspeicherung zur Verfügung steht.
Die Adressberechnung in der Schleife war ein weiteres Problem, da dafür eine Multiplikation nötig war, welche die schon knappen Register noch weiter belegt hätte. Nach einem Ansatz mit einer Schleife und mehrfacher Addition, wurde das Problem mit dem Befehl LEA, der die effektive Adresse des 2. Operanden in das angegebene Register lädt, gelöst. Somit konnte die Adressrechnung registerunabhängig durchgeführt werden.

Der Quellcode steht unter Download auch zum download bereit.

 

Quellcode C-Rahmenprogramm

nach oben

Alle Testläufe wurden mit einem C-Programm durchgeführt. Dieses ließt zuerst die Vektoren und zur Ausführung nötigen Daten ein, zeigt die Vektoren in der ursprünglichen Form an, führt DSWAP aus und gibt daraufhin die nun veränderten Vektoren nochmals aus.

#include <stdio.h> extern void _dswap(int, double*, int, double*, int); int main() {     unsigned int n = 0;     unsigned int incx = 0;     unsigned int incy = 0;     unsigned int len = 0;     int i = 0;     double vector_x [25];     double vector_y [25];     printf ("\nLaenge der Vektoren (c- bedingt unter 25!) ? ");     scanf ("%i", &len);     printf ("\nVektor X\n");     for (i = 0; i < len; i++)     {         printf (" %d te Komponente: ", i);         scanf("%lf",&vector_x [i]);     }     printf ("\n\nVektor Y\n");     for (i = 0; i < len; i++)     {         printf (" %d te Komponente: ", i);         scanf("%lf",&vector_y [i]);     }     printf ("\n\nVertauschungen n ? ");     scanf ("%i", &n);     printf ("\nSchrittweite incx : ");     scanf ("%i", &incx);     printf ("\nSchrittweite incy : ");     scanf ("%i", &incy);     printf ("\n\nOriginalvektoren\n");     printf ("\n X-vektor Y-vektor\n");     for (i = 0; i < len; i++)     {         printf ("\n%lf ", vector_x [i]);         printf (" %lf", vector_y [i]);     }     printf ("\n\nDswap Aufruf\n\n");     _dswap (n, vector_x, incx, vector_y, incy );     printf("\nDswap ausgeführt\n");     printf("\nVeränderte Vektoren\n");     printf ("\n X-vektor Y-vektor\n");     for (i = 0; i < len; i++)     {         printf ("\n%lf ", vector_x [i]);         printf (" %lf", vector_y [i]);     }     printf("\n\n\n");     exit(); }


Mit Hilfe diese Programms wurden mehrere Testläufe bezüglich Funktionalität und Stabilität gemacht. Auch dieser Quellcode wird unter Download zur Verfügung gestellt.