Transcript CoreWar - Lirmm

IUT Montpellier
TP Prog. 2
Informatique
2013/2014
CoreWar
CoreWar est un jeu dans lequel deux programmes se livrent à un combat dans une machine virtuelle.
Chaqu’un des programmes consiste en un ensemble d’instructions. L’espace où se déroule le jeu est
un tableau où chaque élément du tableau peut contenir une instruction. Usuellement, ce tableau
est de taille 4096 et il est initialement remplit avec l’instruction "DAT 0". A noter que la mémoire
est cyclique (ainsi l’adresse mémoire 4097 correspond à l’adresse 0 si la tableau à taille 4096). Au
début du jeu, les deux programmes sont copiés à des emplacements aléatoires dans ce tableau (mais
ils ne doivent pas se chevaucher). Lorsque le jeu est lancé, les instructions des deux programmes
sont éxécutés à tour de rôle (une instruction par tour) - un pointeur d’instruction garde la trace de
la prochaine instruction à éxécuter pour chacun des deux programmes.
Conditions de victoire : Un programme "meurt" après avoir exécuté une instruction illégale.
Si après un certains nombre de tour les deux programmes sont toujours "vivants" alors la partie est
déclarée nulle.
Question 1. Créer l’ensemble de classes adéquat pour représenter les différents modes d’adressage.
Question 2. Créer l’ensemble de classes adéquat pour représenter les différentes instructions.
Question 3. Implémenter les méthodes pour convertir une instruction en entier, convertir un entier
en instruction (cf plus bas), implémenter la méthode toString() dans les différente classe.
Question 4. Créer la classe représentant la mémoire du programme ainsi que les méthodes pour
écrire et lire dans cette mémoire. On considèrera que la mémoire est un tableau d’entiers.
Question 5. Implémenter le mécanisme d’éxécution des différentes instructions ainsi que la gestion
des instructions illégales (utiliser les exceptions de Java).
Question 6. Créer la classe représentant le processeur. Fournir les méthodes permettant l’interface
avec la mémoire. Enfin écrire la méthode permettant le chargement et la compilation des programmes ainsi l’éxécution et l’affichage du jeu.
Correspondance entier et instruction
Il existe une correspondance bijective entre une instruction et un entier codé sur 32 bits. Chaque
type d’instruction est représenté par un nombre entier (Opcode). De même à chaque type de mode
d’adressage est associés. Ces codes sont décrit dans les tableau des sections suivantes Chaque instruction peut être codé de la manière suivante :
Champs
Nombre de bits
Opcode
4
Mode d’adressage (A)
2
1
Mode d’adressage (B)
2
Operande (A)
12
Operande (B)
12
Par exemple, l’instruction "MOV #1, $2" sera représenté en binaire par la chaine :
00010001000000000001000000000010
La chaine peut être décomposé de la manière suivante :
• l’opcode de l’instruction MOV est "1", soit "0001" en binaire codé sur 4 bits.
• le code de l’adressage immédiat est "0", soit "00" en binaire codé sur 2 bits. De même le code
de l’adressage relatif est "01" en binaire sur 2 bits.
• Les deux opérandes correspondent à "1" et "2" respectivement, soit "000000000001" et "000000000010"
en binaire codé sur 12 bits.
Notons que l’opcode de l’instruction est codé sur 4 bits (soit 16 valeurs possible) alors qu’il n’existe
que 8 instructions dans ce sujet. Pour convertir un entier quelconque, on considèrera la valeur
entière de ces 4 bits réduite modulo 8. De même pour les adressages, on considèrera la valeur
binaire des 2 bits réduite modulo 3.
Modes d’adressage
Code
0
Symbole
#
1
$
2
@
Description
Adressage immédiat (représente une
constante numérique.
Adressage relatif (désigne le
contenu d’une case relativement
à l’instruction courante.
Adressage relatif indirect (désigne l’
adresse relative de la case contenant
l’adresse relative de la case pointé (!)
2
Instructions
Opcode
0
Symbole
DAT
Adressage A
#
Adressage B
-
Arg1
A
Arg2
-
1
2
MOV
ADD
#$@
#$@
$@
$@
A
A
B
B
3
SUB
#$@
$@
A
B
4
JMP
-
$@
-
B
5
JMZ
#$@
$@
A
B
6
DJZ
$@
$@
A
B
7
CMP
#$@
#$@
A
B
Description
Constante mémoire initialisé à A,
non éxécutable.
Copie A dans l’emplacement B.
Ajoute A au contenu de B et
le stoke dans B.
Soustrait A de l’emplacement B
et stoke le résultat dans B.
Modifie le pointeur d’instruction
pour lui attribuer la valeur B.
Si l’opérange A vaut 0, modifie
le pointeur d’instruction pour
lui faire prendre la valeur B;
Sinon continuer avec l’instruction
suivante.
Décremente la valeur contenu à
l’emplacement A de 1. Si A vaut 0
alors le pointeur d’instruction prend
la valeur B; sinon continu avec
l’instruction suivante.
Compare A avec B. S’ils sont différents,
saute l’instruction suivante, sinon
continu avec l’instruction suivante.
Exemple: MOV #1, $2 - Copie la valeur 1 dans la case situé 2 cases suivant la case courante.
La tentative d’éxécution d’une instruction "DAT" ou d’une instruction ne correspondant pas à un
des cas énumérés dans le tableau ci-dessus engendre la mort du programme ayant exécuté cette
instruction.
3