Costes ocultos en arrays de estructuras en C

// Cabecera principal de CPCtelera
// Para este ejemplo, se utiliza CPCtelera 1.4.2
#include <cpctelera.h>
 
//-------------------------------------------------------
// Declaración de estructura para almacenar una entidad
//  7 bytes que incluyen posición, energía,
//  estado y puntero al sprite
//-------------------------------------------------------
typedef struct {
   u8  x, y;
   u16 energy;
   u8* sprite;
   u8  state;
} TEntity;
 
//-------------------------------------------------------
// Constantes y variables globales
//-------------------------------------------------------
// Constante: Energías para nuestras 10 entidades
const u16 energies[10] = { 1000, 600, 900, 1100, 600, 750, 1200, 900, 500, 880 };
// Constante: Datos de los píxeles de un sprite para poder pintarlo en pantalla
const u8  sprite1[10]  = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
// Variable: Array de entidades (todo inicializado a 0 por defecto)
TEntity entities[10];
 
//-------------------------------------------------------
// Programa principal
//   Simula la inicialización del array de entidades
//   utilizando un bucle con código para asignar los valores
//-------------------------------------------------------
void main() {
   u8 i, j = 10;
 
   // Recorre todas las entidades y asigna los 
   // valores iniciales una por una
   for(i=0; i < 10; i++) {
      --j;
      entities[i].energy = energies[j];
      entities[i].state  = 2;
      entities[i].x      = 10;
      entities[i].y      = 10;
      entities[i].sprite = sprite1;
   }
 
   // Bloquearse para siempre
   while(1);
}

;src/main.c:50: void main() {
;	---------------------------------
; Function main
; ---------------------------------
_main::
	push	ix             ; Código para manejar la PILA al entrar a la funcion main
	ld	ix,#0
	add	ix,sp
	push	af
	push	af
;src/main.c:55: for(i=0; i < 10; i++) {
	ld	-4 (ix), #0x0a ; Guardamos 10 (0x0A) en (IX-4) { Variable j }
	ld	-3 (ix), #0x00 ; Guardamos  0 (0x00) en (IX-3) { Variable i }
00105$:
;src/main.c:56: --j;
	dec	-4 (ix)        ; Decrementamos la variable j (IX-4)
;src/main.c:57: entities[i].energy = energies[j];
	ld	c,-3 (ix)      ; C = variable i
	ld	b,#0x00        ; B = 0
	ld	l, c           ; / HL = BC { variable i en 16 bits }
	ld	h, b           ; \ 
	add	hl, hl         ; /
	add	hl, bc         ; | HL = HL * 10
	add	hl, hl         ; | Cada elemento del array son 10 bytes
	add	hl, bc         ; \ Así que hay que ir hasta entities + i * 10
	ld	bc,#_entities  ; BC = Dirección donde empieza entities
	add	hl,bc          ; HL = HL + BC  { entities + i * 10 }
	ld	c, l           ; / BC = HL { Salvamos en BC una copia
	ld	b, h           ; \ de la dirección de este elemento i }
	ld	hl, #0x0002    ; / HL += 2 { 2 bytes más adelante de donde empieza
	add	hl,bc          ; \ este elemento, está almacenado su 'energy' }
	ld	-2 (ix), l     ; / Salvamos esta dirección de memoria (HL)
	ld	-1 (ix), h     ; \ en las posiciones (IX-1) e (IX-2) de memoria
	ld	l, -4 (ix)     ; L = (IX-4) = valor de la variable j
	ld	h, #0x00       ; H = 0, así que HL = valor de variable j en 16 bits
	add	hl, hl         ; HL *= 2 { Cada elemento de energies es 2 bytes }
	ld	de, #_energies ; DE = Dirección de memoria de energies
	add	hl, de         ; HL += DE { energies + 2*j, para llegar al elemento j }
	ld	e, (hl)        ; / Guardamos DE en energies[j] en memoria
	inc	hl             ; | DE = energies[j] { es de 16 bits }
	ld	d, (hl)        ; \
	ld	l,-2 (ix)      ; / HL Vuelve a apuntar a entities[i].energy
	ld	h,-1 (ix)      ; \ { lo habíamos salvado antes en (IX-1) (IX-2) }
	ld	(hl), e        ; /
	inc	hl             ; | Almacenamos DE   { energies[j] } 
	ld	(hl), d        ; \ donde apunta HL  { entities[i].energy }
;src/main.c:58: entities[i].state  = 2;
	ld	hl, #0x0006    ; HL = 6   { Distancia de entities[i] hasta state }
	add	hl, bc         ; HL += BC { HL = entities[i] + 6 }
                               ; Recordemos que BC conserva la dirección de entities + 10*i
	ld	(hl), #0x02    ; Almacenamos el 2 en (HL) { entities[i].state }
;src/main.c:59: entities[i].x      = 10;
	ld	a, #0x0a       ; A = 10 { 0x0A }
	ld	(bc), a        ; BC apunta a x, porque es el primer campo de entities, 
                               ; así que guardar a en (BC) es entities[i].x = 10
;src/main.c:60: entities[i].y      = 10;
	ld	l, c           ; / HL = BC { HL apunta a entities[i].x }
	ld	h, b           ; \ 
	inc	hl             ; HL += 1 { Apunta al byte siguiente, que es entities[i].y }
	ld	(hl), #0x0a    ; Almacenamos un 10 { 0x0A } en (HL) { entities[i]. y }
;src/main.c:61: entities[i].sprite = sprite1;
	ld	hl, #0x0004        ; HL = 4   { Distancia de entities[i] a su campo sprite }
	add	hl, bc             ; HL += BC { entities[i] + 4, HL apunta a entities[i].sprite }
	ld	(hl), #<(_sprite1) ; Guardamos el byte bajo de (_sprite) en (HL) { entities[i].sprite }
	inc	hl                 ; HL++ { Apuntamos al siguiente byte, el byte alto del sprite }
	ld	(hl), #>(_sprite1) ; Guardamos el byte alto de (_sprite)
;src/main.c:55: for(i=0; i < 10; i++) {
	inc	-3 (ix)        ; i++ { Recordemos que i está guardada en (IX-3) }
	ld	a, -3 (ix)     ; A = Variable i
	sub	a, #0x0a       ; A - 10 { Para comprobar si vale 10 }
	jr	C,00105$       ; Mientras A != 0 { i != 10 } saltar al comienzo del bucle
;src/main.c:65: while(1);
00103$:
	jr	00103$         ; Bucle infinito

   // Versión anterior (Acceso desordenado)
   for(i=0; i < 10; i++) {
      --j;
      entities[i].energy = energies[j];
      entities[i].state  = 2;
      entities[i].x      = 10;
      entities[i].y      = 10;
      entities[i].sprite = sprite1;
   }

   // Nueva versión (Acceso ordenado)
   for(i=0; i < 10; i++) {
      --j;
      entities[i].x      = 10;
      entities[i].y      = 10;
      entities[i].energy = energies[j];
      entities[i].sprite = sprite1;
      entities[i].state  = 2;
   }

;src/main.c:50: void main() {
;	---------------------------------
; Function main
; ---------------------------------
_main::
	push	ix
	ld	ix,#0
	add	ix,sp
	dec	sp
;src/main.c:55: for(i=0; i < 10; i++) {
	ld	-1 (ix), #0x0a
	ld	c, #0x00
00105$:
;src/main.c:56: --j;
	dec	-1 (ix)
;src/main.c:57: entities[i].x      = 10;
	ld	b,#0x00
	ld	l, c
	ld	h, b
	add	hl, hl
	add	hl, bc
	add	hl, hl
	add	hl, bc
	ex	de,hl
	ld	hl, #_entities
	add	hl,de
	ex	de,hl
	ld	a, #0x0a
	ld	(de), a
;src/main.c:58: entities[i].y      = 10;
	ld	l, e
	ld	h, d
	inc	hl
	ld	(hl), #0x0a
;src/main.c:59: entities[i].energy = energies[j];
	push	de
	pop	iy
	inc	iy
	inc	iy
	ld	l, -1 (ix)
	ld	h, #0x00
	add	hl, hl
	ld	a, #<(_energies)
	add	a, l
	ld	l, a
	ld	a, #>(_energies)
	adc	a, h
	ld	h, a
	ld	a, (hl)
	inc	hl
	ld	b, (hl)
	ld	0 (iy), a
	ld	1 (iy), b
;src/main.c:60: entities[i].sprite = sprite1;
	ld	hl, #0x0004
	add	hl, de
	ld	(hl), #<(_sprite1)
	inc	hl
	ld	(hl), #>(_sprite1)
;src/main.c:61: entities[i].state  = 2;
	ld	hl, #0x0006
	add	hl, de
	ld	(hl), #0x02
;src/main.c:55: for(i=0; i < 10; i++) {
	inc	c
	ld	a, c
	sub	a, #0x0a
	jr	C,00105$
;src/main.c:65: while(1);
00103$:
	jr	00103$

   // Versión anterior, accediendo al array a través de
   // índice (i) con cálculos asociados
   for(i=0; i < 10; i++) {
      --j;
      entities[i].x      = 10;
      entities[i].y      = 10;
      entities[i].energy = energies[j];
      entities[i].sprite = sprite1;
      entities[i].state  = 2;
   }

   // Nueva versión usando un puntero para ir recorriendo
   // los elementos del array, sumando 1 TEntity cada vez
   // El puntero e, apunta al inicio del vector entities
   TEntity* e = entities;
 
   for(i=0; i < 10; i++) {
      --j;
      e->x      = 10;
      e->y      = 10;
      e->energy = energies[j];
      e->sprite = sprite1;
      e->state  = 2;
      // Sumar +1 TEntity al puntero (+7 bytes)
      ++e;
   }

_main::
;src/main.c:54: TEntity* e = entities;
	ld	bc, #_entities+0
;src/main.c:55: for(i=0; i < 10; i++) {
	ld	de,#0x0a0a
00107$:
;src/main.c:56: --j;
	dec	d
;src/main.c:57: e->x      = 10;
	ld	a, #0x0a
	ld	(bc), a
;src/main.c:58: e->y      = 10;
	ld	l, c
	ld	h, b
	inc	hl
	ld	(hl), #0x0a
;src/main.c:59: e->energy = energies[j];
	push	bc
	pop	iy
	inc	iy
	inc	iy
	ld	l, d
	ld	h, #0x00
	add	hl, hl
	ld	a, #<(_energies)
	add	a, l
	ld	l, a
	ld	a, #>(_energies)
	adc	a, h
	ld	h, a
	ld	a, (hl)
	inc	hl
	ld	h, (hl)
	ld	0 (iy), a
	ld	1 (iy), h
;src/main.c:60: e->sprite = sprite1;
	ld	hl, #0x0004
	add	hl, bc
	ld	(hl), #<(_sprite1)
	inc	hl
	ld	(hl), #>(_sprite1)
;src/main.c:61: e->state  = 2;
	ld	hl, #0x0006
	add	hl, bc
	ld	(hl), #0x02
;src/main.c:62: ++e;            // Sumar 1 TEntity al puntero (7 bytes)
	ld	hl, #0x0007
	add	hl,bc
	ld	c, l
	ld	b, h
	ld	l, e
	dec	l
;src/main.c:55: for(i=0; i < 10; i++) {
	ld	a,l
	ld	e,a
	or	a, a
	jr	NZ,00107$
;src/main.c:66: while(1);
00103$:
	jr	00103$

   // Versión anterior usando *e como puntero
   // para evitar los cálculos de entities[i]
   u8 i, j = 10;
   TEntity* e = entities;
   for(i=0; i < 10; i++) {
      --j;
      e->x      = 10;
      e->y      = 10;
      e->energy = energies[j];
      e->sprite = sprite1;
      e->state  = 2;
      ++e;  // Sumar 1 TEntity al puntero (7 bytes)
   }

   // Nueva versión
   // Usamos *e para acceder a entities
   // y *ene para acceder a energies eliminando
   // la variable j y el coste de energies[j]
   TEntity* e = entities;
   u16* ene = energies + 9;
 
   // Para eliminar la necesidad de la variable i
   // Usamos el propio puntero *e para saber cuando
   // hemos terminado: cuando apunte a la primera
   // posición fuera de array, es decir entities + 10
   // (No olvidemos que +10 = +10*TEntity = +70 bytes)
   while(e != (entities + 10)) {
      e->x      = 10;
      e->y      = 10;
      e->energy = *ene;
      e->sprite = sprite1;
      e->state  = 2;
      ++e;    // Sumar  +1 TEntity al puntero (+7 bytes)
      --ene;  // Restar -1 u16 al puntero (-2 bytes)
   }

;src/main.c:50: void main() {
;	---------------------------------
; Function main
; ---------------------------------
_main::
;src/main.c:68: TEntity* e = entities;
	ld	bc, #_entities
;src/main.c:69: u16* ene = energies + 10;
	ld	de, #_energies+20
;src/main.c:76: while(e != (entities + 10)) {
00101$:
	ld	a, c
	sub	a, #<((_entities + 0x0046))
	jr	NZ,00122$
	ld	a, b
	sub	a, #>((_entities + 0x0046))
	jr	Z,00105$
00122$:
;src/main.c:77: e->x      = 10;
	ld	a, #0x0a
	ld	(bc), a
;src/main.c:78: e->y      = 10;
	ld	l, c
	ld	h, b
	inc	hl
	ld	(hl), #0x0a
;src/main.c:79: --ene;
	dec	de
	dec	de
;src/main.c:80: e->energy = *ene;
	push	bc
	pop	iy
	inc	iy
	inc	iy
	ld	l, e
	ld	h, d
	ld	a, (hl)
	inc	hl
	ld	h, (hl)
	ld	0 (iy), a
	ld	1 (iy), h
;src/main.c:81: e->sprite = sprite1;
	ld	hl, #0x0004
	add	hl, bc
	ld	(hl), #<(_sprite1)
	inc	hl
	ld	(hl), #>(_sprite1)
;src/main.c:82: e->state  = 2;
	ld	hl, #0x0006
	add	hl, bc
	ld	(hl), #0x02
;src/main.c:83: ++e;    // Sumar  +1 TEntity al puntero (+7 bytes)
	ld	hl, #0x0007
	add	hl,bc
	ld	c, l
	ld	b, h
	jr	00101$
;src/main.c:88: while(1);
00105$:
	jr	00105$