Vektoren: Indizierung nach Position

Ein Vektor ist ein Array: eine Folge von Zahlen, die im Speicher nebeneinander abgelegt sind. In der vorherigen Lektion hast du einen summiert, indem du einen Zeiger für jedes Element um 4 Bytes vorwärts bewegt hast. Dieselbe Methode funktioniert auch hier. Es gibt eine weitere gängige Möglichkeit, auf ein Element zuzugreifen: über den Index. Ein Index ist die Position eines Elements vom Anfang an gezählt, wobei das erste Element den Index 0 hat, das zweite den Index 1, und so weiter.

Einen Vektor durch einen wandernden Zeiger summieren

.data
a: .word 5, 10, 15, 20 # vier Elemente
.text
la   t0, a # t0 = Adresse von a
li   t1, 4 # t1 = Anzahl der verbleibenden Elemente
li   t2, 0 # t2 = laufende Summe
loop:
  beq  t1, zero, done
  lw   t3, 0(t0) # lädt das aktuelle Element
  add  t2, t2, t3 # addiert zur Summe
  addi t0, t0, 4 # zum nächsten Wort weiter (4 Bytes)
  addi t1, t1, -1 # eines weniger
  j loop
done:
  mv a0, t2 # gibt die Summe aus: 5+10+15+20 = 50
  li a7, 1
  ecall
  li a7, 10
  ecall

Die Schleife läuft wie folgt ab. t0 enthält die Adresse von a, und t1 enthält die Anzahl der verbleibenden Elemente, beginnend bei 4. Bei jedem Durchlauf beendet beq t1, zero, done die Schleife, wenn der Zähler null erreicht. lw t3, 0(t0) lädt das Element an der Adresse in t0. add t2, t2, t3 addiert diesen Wert zur laufenden Summe. addi t0, t0, 4 rückt den Zeiger zum nächsten Wort vor. addi t1, t1, -1 verringert den Zähler. Nach vier Durchläufen (5 + 10 + 15 + 20) gibt done 50 aus. Dies ist dasselbe Muster wie in der Speicher-Lektion, nun auf einen Vektor angewendet.

Vom Index zur Adresse

Die Indexierung berechnet eine Adresse aus einem Basiszeiger und einer Position: address = base + index * 4. Die 4 ist die Größe eines Wortes in Bytes. Ein Compiler erzeugt dieselbe Berechnung für a[i] in einer Sprache wie C. Der Index selbst greift nie auf den Speicher zu. Nur die daraus berechnete Adresse tut dies.

slli t5, t3, 2 # t5 = Index * 4 (Wortgröße)
add  t6, t0, t5 # t6 = Adresse von element[index]
lw   t6, 0(t6) # t6 = element[index]

slli t5, t3, 2 verschiebt den Index in t3 um 2 Bits nach links, was ihn mit 4 multipliziert (zwei Verdopplungen: 2 x 2), der Größe eines Wortes. Addiert man das Ergebnis zum Basiszeiger, erhält man die Adresse von element[index]. Diese Verschiebung ist dieselbe Zweierpotenz-Methode aus der Arithmetik-Lektion, und sie ist die Standardmethode, um einen Index mit der Größe eines Wortes zu skalieren.

Einen Vektor per Index summieren

.data
a: .word 5, 10, 15, 20 # vier Elemente
.text
la   t0, a # t0 = Basisadresse von a
li   t1, 4 # t1 = Anzahl der Elemente
li   t2, 0 # t2 = Index, beginnt bei 0
li   t3, 0 # t3 = laufende Summe
loop:
  beq  t2, t1, done
  slli t4, t2, 2 # t4 = Index * 4 (Byte-Offset)
  add  t5, t0, t4 # t5 = Adresse von a[index]
  lw   t5, 0(t5) # t5 = a[index]
  add  t3, t3, t5 # total += a[index]
  addi t2, t2, 1 # zum nächsten Index weiter
  j loop
done:
  mv a0, t3 # gibt die Summe aus: 5+10+15+20 = 50
  li a7, 1
  ecall
  li a7, 10
  ecall

Die Schleife läuft wie folgt ab. t2 ist der Index, beginnend bei 0. Bei jedem Durchlauf beendet beq t2, t1, done die Schleife, wenn der Index 4 erreicht, die in t1 gehaltene Elementanzahl. slli t4, t2, 2 wandelt den Index in einen Byte-Offset um. add t5, t0, t4 addiert diesen Offset zur Basisadresse in t0, um die Adresse von a[index] zu erzeugen. lw t5, 0(t5) lädt den dort gespeicherten Wert. Dieser Wert wird zur laufenden Summe in t3 addiert, und addi t2, t2, 1 rückt zum nächsten Index vor. Nach vier Durchläufen (5 + 10 + 15 + 20) gibt done 50 aus.

Addition zweier Vektoren, Element für Element

.data
a: .word 3, 6, 9, 12 # erster Vektor
b: .word 1, 2, 3, 4 # zweiter Vektor
c: .space 16 # Platz für 4 Ergebniswörter
.text
la   t0, a # Basisadresse von a
la   t1, b # Basisadresse von b
la   t2, c # Basisadresse von c
li   t3, 0 # Index, beginnt bei 0
li   t4, 4 # Anzahl der Elemente
li   s0, 0 # laufende Summe
loop:
  beq  t3, t4, done
  slli t5, t3, 2 # Byte-Offset = Index * 4
  add  t6, t0, t5 # Adresse von a[index]
  lw   t6, 0(t6) # Wert von a[index]
  add  a0, t1, t5 # Adresse von b[index]
  lw   a0, 0(a0) # Wert von b[index]
  add  t6, t6, a0 # a[index] + b[index]
  add  a0, t2, t5 # Adresse von c[index]
  sw   t6, 0(a0) # c[index] = a[index] + b[index]
  add  s0, s0, t6 # Summe += c[index]
  addi t3, t3, 1 # zum nächsten Index weiter
  j loop
done:
  mv a0, s0 # gibt die Summe aus: 4+8+12+16 = 40
  li a7, 1
  ecall
  li a7, 10
  ecall

Die Schleife läuft wie folgt ab. slli t5, t3, 2 wandelt den Index t3 in einen Byte-Offset um. Addiert man ihn zu jedem Basiszeiger (t0, t1, t2), erhält man die Adressen von a[i], b[i] und c[i]. Bei jedem Durchlauf werden beide Elemente geladen, addiert, in c gespeichert und zur laufenden Summe in s0 addiert. addi t3, t3, 1 rückt zum nächsten Index vor, und die Schleife wiederholt sich, bis alle vier Elemente verarbeitet sind.