Вектори: індексація за позицією

Вектор — це масив: послідовність чисел, що зберігаються поруч одне з одним у пам'яті. У попередньому уроці ви підсумовували його, переміщуючи вказівник уперед на 4 байти для кожного елемента. Той самий метод працює й тут. Є ще один поширений спосіб дістатися до елемента: за індексом. Індекс — це позиція елемента, що відраховується від початку, де перший елемент має індекс 0, другий має індекс 1, і так далі.

Підсумовування вектора просуванням вказівника

.data
a: .word 5, 10, 15, 20 # чотири елементи
.text
la   t0, a # t0 = адреса a
li   t1, 4 # t1 = кількість елементів, що залишилися
li   t2, 0 # t2 = поточна сума
loop:
  beq  t1, zero, done
  lw   t3, 0(t0) # завантажити поточний елемент
  add  t2, t2, t3 # додати до суми
  addi t0, t0, 4 # перейти до наступного слова (4 байти)
  addi t1, t1, -1 # на один менше залишилося
  j loop
done:
  mv a0, t2 # вивести суму: 5+10+15+20 = 50
  li a7, 1
  ecall
  li a7, 10
  ecall

Цикл виконується так. t0 зберігає адресу a, а t1 зберігає кількість елементів, що залишилися, починаючи з 4. На кожному проході beq t1, zero, done завершує цикл, коли лічильник досягає нуля. lw t3, 0(t0) завантажує елемент за адресою в t0. add t2, t2, t3 додає це значення до поточної суми. addi t0, t0, 4 просуває вказівник до наступного слова. addi t1, t1, -1 зменшує лічильник. Після чотирьох проходів (5 + 10 + 15 + 20) done виводить 50. Це той самий шаблон, використаний в уроці про пам'ять, тепер застосований до вектора.

Від індексу до адреси

Індексація обчислює адресу з базового вказівника та позиції: address = base + index * 4. Число 4 — це розмір слова в байтах. Компілятор генерує таке саме обчислення для a[i] у такій мові, як C. Сам індекс ніколи не звертається до пам'яті. Це робить лише обчислена з нього адреса.

slli t5, t3, 2 # t5 = індекс * 4 (розмір слова)
add  t6, t0, t5 # t6 = адреса element[index]
lw   t6, 0(t6) # t6 = element[index]

slli t5, t3, 2 зсуває індекс у t3 вліво на 2 біти, що множить його на 4 (два подвоєння: 2 x 2) — розмір одного слова. Додавання результату до базового вказівника дає адресу element[index]. Цей зсув — той самий метод степенів двійки з уроку арифметики, і це стандартний спосіб масштабування індексу на розмір слова.

Підсумовування вектора за індексом

.data
a: .word 5, 10, 15, 20 # чотири елементи
.text
la   t0, a # t0 = базова адреса a
li   t1, 4 # t1 = кількість елементів
li   t2, 0 # t2 = індекс, починається з 0
li   t3, 0 # t3 = накопичувальна сума
loop:
  beq  t2, t1, done
  slli t4, t2, 2 # t4 = індекс * 4 (зміщення в байтах)
  add  t5, t0, t4 # t5 = адреса a[index]
  lw   t5, 0(t5) # t5 = a[index]
  add  t3, t3, t5 # total += a[index]
  addi t2, t2, 1 # перейти до наступного індексу
  j loop
done:
  mv a0, t3 # вивести total: 5+10+15+20 = 50
  li a7, 1
  ecall
  li a7, 10
  ecall

Цикл виконується так. t2 — це індекс, починаючи з 0. На кожному проході beq t2, t1, done завершує цикл, коли індекс досягає 4 — кількості елементів, що зберігається в t1. slli t4, t2, 2 перетворює індекс на байтове зміщення. add t5, t0, t4 додає це зміщення до базової адреси в t0, щоб отримати адресу a[index]. lw t5, 0(t5) завантажує значення, що там зберігається. Це значення додається до поточної суми в t3, а addi t2, t2, 1 переходить до наступного індексу. Після чотирьох проходів (5 + 10 + 15 + 20) done виводить 50.

Додавання двох векторів, елемент за елементом

.data
a: .word 3, 6, 9, 12 # перший вектор
b: .word 1, 2, 3, 4 # другий вектор
c: .space 16 # місце для 4 слів результату
.text
la   t0, a # базова адреса a
la   t1, b # базова адреса b
la   t2, c # базова адреса c
li   t3, 0 # індекс, починається з 0
li   t4, 4 # кількість елементів
li   s0, 0 # накопичувальна сума
loop:
  beq  t3, t4, done
  slli t5, t3, 2 # зміщення в байтах = індекс * 4
  add  t6, t0, t5 # адреса a[index]
  lw   t6, 0(t6) # значення a[index]
  add  a0, t1, t5 # адреса b[index]
  lw   a0, 0(a0) # значення b[index]
  add  t6, t6, a0 # a[index] + b[index]
  add  a0, t2, t5 # адреса c[index]
  sw   t6, 0(a0) # c[index] = a[index] + b[index]
  add  s0, s0, t6 # total += c[index]
  addi t3, t3, 1 # перейти до наступного індексу
  j loop
done:
  mv a0, s0 # вивести total: 4+8+12+16 = 40
  li a7, 1
  ecall
  li a7, 10
  ecall

Цикл виконується так. slli t5, t3, 2 перетворює індекс t3 на байтове зміщення. Додавання його до кожного базового вказівника (t0, t1, t2) дає адреси a[i], b[i] і c[i]. На кожному проході обидва елементи завантажуються, додаються, зберігаються в c і додаються до поточної суми в s0. addi t3, t3, 1 переходить до наступного індексу, і цикл повторюється, поки всі чотири елементи не буде оброблено.