Allocation de mémoire de plusieurs matrices d'assemblage

Question

Comment allouer de la mémoire dans un assemblage lors de l'utilisation de plusieurs matrices. Par exemple, j'ai 2 tableaux;

la $s0, X 
la $s1, Y 

si « Initialiser » cette façon, l'allocation de mémoire est contiguë, par exemple

Address  +0  +4  +8  +12  ..... 
22112  x[0]  y[0]  x[1]  y[1] ... 
. 
. 
. 

Afin de « corriger » que je pensais de charger l'adresse de tableau de poing d'initialisation n valeurs puis à partir de là initialiser l'autre. Par exemple

arrayAllocationX: 
    la $t0, X 
    fill with $zero until n-1($t0) 
    la $s0, X 

arrayAllocationY: 
    la $t1, Y 
     fill with $zero until n-1($t1) 
    la $s1, Y 

Cela n'a pas fonctionné, comme lorsqu'il indique la $s0, X et la $s1, Y il continue de stocker des valeurs jointive.

Je pense à d'autres façons de le faire qui pourraient fonctionner, par exemple; Si vous remplissez des éléments de manière contiguë et que vous lisez la valeur de l'un des tableaux, vous saisissez 1 adresse mémoire, donc x [0] = Adresse 2234 -> x [1] = 2234 + 8. Mais cela ne semble pas être une bonne pratique de programmation.

Pouvez-vous me conseiller sur la bonne façon de procéder? Merci!

---

Par ailleurs, les valeurs sont toujours entrées et lecture en séquence (première x puis y)

Answer 1

J'espère que je ne suis pas mal interpréter votre question, mais l'allocation de mémoire pour un tableau est généralement fait par une directive spéciale d'assembleur et non par des instructions particulières. Malheureusement, la syntaxe varie mais l'idée générale est de demander à l'assembleur d'allouer de l'espace. Supposons que le tableau X a besoin de 100 ints et le tableau Y 200. Voici comment certains assembleurs font:

X: defs 100*4 
Y: defs 200*4 

D'autres pourraient dire « .byte » au lieu de « defs ». Le "* 4" est parce que vous allouez de l'espace en octets mais chaque int est de 4 octets. Parfois, les assembleurs ont une façon de dire "allouer de l'espace et le remplir avec une certaine valeur". Ce que j'ai présenté ici ne le fera pas pour être sûr que vous devez maintenant écrire les valeurs initiales. Remplissons X avec 1 et de Y avec 2 de:

 la $t0,X   ; get address of X array into $t0 
    mov $t1,100  ; number of items in X into $t1 
    mov $s0,1   ; All X[] to be filled with 1 
xlp: st $s0,0($t0) ; write next X[] value 
    add $t0,$t0,4  ; move to next position in X[] array 
    add $t1,$t1,-1 ; count down one less item 
    bne $t1,0,xlp  ; keep doing this until we get to zero 

    la $t0,Y 
    mov $t1,200 
    mov $s0,2 
ylp: st $s0,0($t0) 
    add $t0,$t0,4 
    add $t1,$t1,-1 
    bne $t1,0,ylp 

Les commentaires sont un peu redondant, mais je voulais Réitérons ce que je fais dans le cas probable que je l'ai oublié mon mnémoniques assembleur MIPS ou ont fait une erreur.

L'allocation dynamique des tableaux est une proposition tout à fait différente. Normalement, il y aura un sous-programme du système d'exploitation que vous appelez pour obtenir un pointeur vers un morceau de mémoire d'une certaine taille. Si vous êtes vraiment à un niveau bas, vous devrez élaborer votre propre plan. Bizarrement, cela revient à déclarer un tableau statique qui couvre toute la mémoire disponible et à en transférer des morceaux au fur et à mesure que le programme le demande. Ensuite, vous devez être compliqué pour garder une trace de ce que vous avez remis afin de libérer des morceaux.

Dans les deux cas, vous recevrez un pointeur sur la quantité de mémoire demandée. Normalement, vous devrez enregistrer ce pointeur dans un emplacement de mémoire, mais il pourrait vivre dans un registre pour un programme simple. Le code d'allocation peut ressembler à ceci:

X:  word 0 

mov $t0,100*8 ; how much memory we will need 
bal alloc  ; get memory -- assume it returns pointer in $t1 
la  $s0,X  ; X pointer address 
st  $t1,0($s0) ; keep track of start of array 

Notez comment nous devons effectuer deux étapes pour obtenir l'adresse de la matrice. Avant "X" était l'adresse de la mémoire à utiliser. Maintenant "X" est l'adresse de 4 octets de mémoire qui contiennent l'adresse du tableau.

Le code d'initialisation précédent fonctionnera comme avant, mais au lieu d'un simple « la t0 $, X », vous aurez à:

la $t0,X 
l $t0,0($t0) 

Si vous êtes familier avec C, la différence ici est la même chose que "int X [100];" vs "int * X = malloc (100 * sizeof (int));". Dans les deux cas, vous pouvez dire "X [n]" mais dans les coulisses, C utilise les bonnes séquences d'assembleur.