Architecture Système Projet 2 - Programmes en langage assembleur

Téléchargement

Architecture Système

Projet 2 - Programmes en langage assembleur

Pasdeloup Bastien - Forestier Sébastien

30 novembre 2011

Table des matières

1 Introduction 3

2 Conventions utilisées 4

2.1 Miseenformedesﬁchiers ............................... 4

2.2 Environnementdetravail ............................... 5

2.3 Gestiondesregistres .................................. 5

2.4 Gestiondelapile.................................... 6

3 Tours de Hanoi 7

3.1 Descriptionduproblème................................ 7

3.2 Algorithme ....................................... 8

3.3 Implémentation..................................... 8

3.4 Exemple......................................... 9

3.5 Analyse ......................................... 9

4 Algorithmes de tri 11

4.1 Descriptionduproblème................................ 11

4.2 Tri"insertion" ..................................... 11

4.2.1 Algorithme ................................... 11

4.2.2 Exemple..................................... 12

4.3 Tri"fusion"....................................... 12

4.3.1 Algorithme ................................... 12

4.3.2 Exemple..................................... 13

4.4 Tri"index" ....................................... 13

4.4.1 Algorithme ................................... 13

4.4.2 Exemple..................................... 14

4.4.3 Implémentation................................. 15

4.5 Analyse ......................................... 15

5 Conclusion 18

Appendices 19

1 Introduction

Ce projet s’inscrit au sein du module "Architecture Système" du Magistère Informatique et

Télécommunications, première année. L’objectif est ici de réaliser un certain nombre de pro-

grammes dans le langage assembleur reconnu par l’interprète Python fourni. La documentation

de ce langage est fournie en annexe 5.

Les programmes à implémenter sont les suivants :

– Les tours de Hanoi (avec trois tours et un nombre d’anneaux arbitraire).

– Plusieurs algorithmes eﬀectuant un tri de caractères imprimables selon leur code ASCII 1.

1. http://fr.wikipedia.org/wiki/American_Standard_Code_for_Information_Interchange

2 Conventions utilisées

2.1 Mise en forme des ﬁchiers

Avant de commencer l’implémentation des programmes en langage assembleur, nous avons

décidé de mettre au point un modèle de ﬁchier aﬁn d’avoir un code uniforme, cohérent et faci-

lement lisible. En eﬀet, l’assembleur est un langage de très bas niveau, et une simple pause café

implique généralement de se replonger dans le code avant de reprendre le travail.

Nous avons donc, pour limiter cette perte de temps, déﬁni les règles suivantes :

– Chaque ﬁchier ne contient qu’un seul programme, découpé le plus possible en fonctions

élémentaires.

– Chaque ﬁchier commence par une fonction main qui initialise les registres liés aux conven-

tions choisies, et exécute la trame globale du programme.

– Chaque fonction est précédée d’un en-tête précisant son nom et sa fonction, ainsi qu’éven-

tuellement les paramètres qu’elle attend et sa valeur de retour.

– Au sein de chaque fonction, des sous-parties sont déﬁnies, aﬁn de distinguer par exemple

la sauvegarde des registres du corps de la fonction, puis de la restauration de ces registres.

– Les instructions assembleur sont alignées en colonnes, regroupant ainsi les labels, les mné-

moniques, les paramètres et les commentaires.

– Chaque instruction est commentée succinctement aﬁn d’expliciter son utilité au sein du

programme.

Nous avons donc de manière générale des ﬁchiers formatés ainsi :

#################################################################################################

# #

# FUNCTI O N : main #

# #

# DESC R I P TION : Start of the the program . In i t i aliz e s the stack at the end of the memor y . #

# Reads the cont e n t o f the input file , orders it and di s p l a y s the result . #

# #

#################################################################################################

# label i n s truc t i o n param1 param2 param3 #

#################################################################################################

### # ### # # ## # # ## # # ### # # ## # # # INI T I ALIZ A T ION # # # ### # # ## # # ## # # ### # # ## # # #

main : XOR R29 R29 R29 # R29 = 0

ADDi R30 R29 65535 # SP = 2^16 - 1 (end of . . .

########################## GLOBAL CONSTANTS #########################

A DD i R 28 R29 1 # R 28 = 1 ( not t o b e . ..

################################ BODY ###############################

ST R29 R30 # We push @T = 0 on ...

SUBi R30 R30 1 # SP --

CALL pars e I n # Proce d u r e that reads . ..

Figure 1 – Exemple d’organisation des ﬁchiers

2.2 Environnement de travail

Toujours aﬁn de nous simpliﬁer la vie, nous avons édité le script python interprétant le lan-

gage en lui donnant en paramètre un booléen indiquant l’activation ou non d’un mode debug.

Nous avons ainsi pu voir, à chaque instruction, l’état des registres, du début de la mémoire

et du début de la pile :

REGIS T E R S = [( R0 = 475); ( R1 = 897); (R2 = 988); (R3 = 776); (R4 = 884); (R5 = 30 9 ) ; ( R6 = 639); (R7 = 761); (R8 = 751); ...]

STACK = [132; 328; 869; 922; 207; 623; 995; 490; 986; 373; 933; 669; 626; 914; 252; 654; 541; 505; 530; 437; 648; 527; ...]