DEUST TSIC

Marc LASNIER

marc.lasnier@chicreteil.fr

M1 Systèmes Informatiques et Bases de Réseaux- Devoir 1

11/12/2003

1. Arithmétique

1ère opération :					2ème  opération :

	1110101011					     1100110011
       +	0111001110				            *	       110
      _____________			          		 _____________

        1	0101111001					    0000000000
						        	  1100110011
							1100110011
							_____________
							
						          1001100110010

3ème  opération : division      32450	|__43__   en base 6
					|
					|

Le calcul de cette division est représenté par :
			     32450	|__43__   					
			       245	|    434
			         320	|		
			            20	|

Explication détaillée :
•	On commence par effectuer  324	|    43    
				     	   24	|    4	
le quotient est 4 ; 	4*3 = 20 ; 0 ôté de 4 égal 4 et on retient 2
			4*4 = 24 ; 24 + 2 (retenue) = 30 ; 30 ôté de 32 égal 2

•	On abaisse le 5 et on continue en effectuant     245   |__43__
      		        32   |    3
	le quotient est 3 ;	3*3 = 13 ; 3 ôté de 5 égal 2 et on retient 1
				3*4 = 20 ; 20 + 1 (retenue) = 21 ; 21 ôté de 24 égal 3

•	On abaisse le 0 et on termine en effectuant      320	|    43    
				     	   		       20	|    4	
le quotient est 4 ;	4*3 = 20 ; 0 ôté de 0 égal 0 et on retient 2
				4*4 = 24 ; 24 + 2 (retenue) = 30 ; 30 ôté de 32 égal 2

Le quotient est 434, le reste est 20.

3. Technologie : Serial ATA
Dans les débuts de la micro-informatique, c’est l'interface série, considérée comme la plus simple à réaliser, qui était essentiellement utilisée. La vitesse de transfert de l'information augmentant, l'interface parallèle s'imposa, de l'imprimante au disque dur ou au lecteur de CD-ROM. Les interfaces série des PC furent alors réservées aux périphériques de performances modestes : clavier, track-ball, lecteur de codes-barres, etc. Cependant, la fréquence de fonctionnement des composants s'élevant sans cesse, et les vitesses de transfert augmentant toujours, les signaux propagés en parallèle présentent des problèmes de synchronisation et d’interférences. On retrouve l'interface série dans l'USB 1 et 2, dans le FireWire (IEEE 1394) et maintenant dans la nouvelle interface Serial ATA (et demain dans la prochaine version de l'interface SCSI, appelée Serial Attached SCSI).
La normalisation de la nouvelle architecture série de l'ATA a été confiée au comité T13 de l'INCITS. Elle est destinée principalement aux unités de stockage internes, et permet pour l’instant un taux de transfert de 150 Mo/s dans sa version 1.0. Bien que le bénéfice soit modeste par rapport à l’Ultra ATA 133, les avantages immédiats sont les suivants :
•	on ne partage pas la bande passante entre plusieurs unités de stockage comme pour l’ATA, chacune étant reliée à une interface dédiée
•	seulement quatre signaux sont utilisés pour l’émission et la réception de données : les câbles sont donc beaucoup plus minces (8mm), les connecteurs plus petits
(7 broches). Ils sont plus faciles à monter et prennent moins de place dans la machine ; la ventilation est donc plus efficace
•	la longueur maximale du câble est plus grande (1 m contre 0,6 m) 
•	il n'y a plus de cavalier à installer pour déclarer le périphérique comme maître ou comme esclave
•	les disques durs peuvent être connectés ou déconnectés sans arrêter l'ordinateur
•	des adaptateurs permettent de connecter des disques durs parallèles ATA à un port Serial ATA
•	la correction d’erreurs est prise en charge lors du transfert des données (déjà présente en SCSI depuis l’Ultra SCSI 160)
Seuls des disques durs répondant à cette norme sont actuellement commercialisés. Les graveurs le seront en 2004 (Philips a fait la démonstration d’un graveur de DVD+RW compatible il y a un an).
A cette date devrait apparaître la version 2 de Serial ATA, avec des débits de 300 Mo/s.
Lors du dernier Intel Developer Forum en septembre dernier, le groupe de travail Serial 
ATA II a introduit de nouvelles spécifications destinées à accélérer le développement et l'implémentation de l'interface Serial ATA II dans les PC, les serveurs et les unités de stockage réseau. Elle intégrera la technologie Command Queuing permettant au contrôleur Serial ATA de recevoir plusieurs requêtes du processeur, afin d’accroître les performances des serveurs et unités de stockage réseau. Vers 2007, le débit devrait passer à 600 Mo/s.
Le successeur de l’interface ATA pour unités de stockage internes vise des performances et une fiabilité accrues, en plus d’une installation simplifiée notamment grâce au branchement à chaud des périphériques.
Sources :	www.serialata.org
		www.ata-atapi/sata
		www.dataligence.com
		www.tech-report.com

3. Exercice d’assembleur

3.1 Résultat : le programme crible.s affiche les nombres premiers inférieurs à 100.

3.2 Articulation générale :
 
1ère partie : lignes 1 à 25. Déclarations, initialisation des registres.
2ème partie : étiquettes $L2 et $L5. Tous les nombres de 2 à 100 sont créés et stockés en mémoire.
3ème partie : étiquettes $L3, $L6, $L9, $L11, $L14, $L1f et $L13.
Le premier nombre de ce « tableau », 2, est utilisé comme diviseur successif des 98 autres en commençant par 3. Si un nombre est divisible par 2, le nombre est remplacé par un 0.
Le nombre 3 est ensuite utilisé comme diviseur successif des 97 autres ; s’il rencontre un 0 il passe au suivant. Si un nombre est divisible par 3, le nombre est remplacé par un 0.
Tous les nombres suivants, de 4 à 100, sont ainsi de suite utilisés comme diviseurs. Ne restent alors dans le « tableau » que des 0 et les nombres qui ne sont pas divisibles par d’autres : les nombres premiers.
4ème partie : étiquettes $L8, $L6, $L7, $L16, $L19 et $L18.
Le « tableau » est parcouru et les nombres différents de 0 sont affichés avec le caractère séparateur ‘-‘.
5ème partie : étiquette $L17. Restauration des valeurs des registres et fin.

3.3 Explication détaillée :

2ème partie : création du tableau des nombres de 2 à 100.
Le nombre 2 a été précédemment chargé en mémoire par les instructions des lignes 24 et 25.
$L2: contrôle si le nombre est < 101 ; si oui on continue en $L5, sinon le tableau est terminé et on
passe à la 3ème partie (en $L3)
$L5: le contenu du registre $2 (c-à-d le nombre 2) est décallé à gauche de 2 bits (= multiplication
par 4) ; le résultat 8 est rangé dans $3. Par les 2 instructions addu, on créé un déplacement 
(mode d’adressage indirect du MIPS) : on vient de créer une adresse.
	L’instruction suivante sw provoque l’écriture de 2 à l’adresse précédemment créée.
	On incrémente alors pour passer de 2 à 3 et l’instruction j  $L2 provoque le retour au début
de la boucle en $L2
En résumé, pour chaque nombre de 2 à 100, une adresse est créée à partir de sa valeur (multiplication et somme) et le nombre y est stocké.

3ème partie : détection des nombres premiers et « annulation » des autres.
$L3 : chargement et écriture en mémoire de 2
$L6 : contrôle si le nombre est < 101, si oui on continue à $L9, sinon saut à $L7
$L9 : création de l’adresse du nombre à lire et lecture de ce nombre (on commence par 2)
incrémentation puis rangement en mémoire du nombre suivant, ici 3
$L11 : contrôle si le nombre suivant est < 101, si oui on continue, sinon saut à $L8 (4ème partie)
$L14 : création de l’adresse où se trouve le nombre suivant, chargement des nombres en vue de la
	division : $2 contient 2 et $3 contient 3
	div  $0,$3,$2	: on effectue la division de 3 par 2
			  le quotient 1 est rangé dans $lo, le reste 1 est rangé dans $hi
$1f : si le reste est différent de 0 (ici oui car 3 n’est pas divisible par 2), on continue à $L13
$L13 : on incrémente le nombre suivant (ici on passe de 3 à 4) et on retourne à $L11
	$L11 : contrôle < 101
	$L14 : $2 contient 2 et $3 contient maintenant 4 ; le reste de la division de 4 par 2 est 0
	$1f : comme le reste est 0 (4 est divisible par 2, donc n’est pas premier), on crée l’adresse
		où se trouve 4 et on écrit 0 à la place avec l’instruction 	sw   $0,0($2)
		on incrémente alors pour passer de 4 à 5 et on retourne à $L11
Ainsi tous les multiples de 2 seront mis à 0. Lorsque le diviseur sera 3, la division ne sera pas effectuée s’il rencontre un 0 grâce à l’instruction 	$L14    beq	$2,$0,L13 : on passe alors directement au suivant en incrémentant.
Quand le tableau a été totalement parcouru, l’instruction    $L11    slt	$2,$2,101      provoque le chargement de 0 dans $2, puis le saut à $L8 pour la 4ème partie.
En résumé, chaque nombre premier du tableau a été remplacé par un 0.

4ème partie :affichage
$L8 : incrémentation du dernier chiffre du tableau : on obtient 101 et saut à $L6
$L6 : le contrôle < 101 provoque le saut à $L7
$L7 : chargement et écriture en mémoire de 2
$L16 : contrôle si 2 < 101, oui donc on continue en $L19
$L19 : 2 n’a pas été remplacé par 0 dans le tableau, donc on continue.
	Après l’appel de la fonction printf, $2 est chargé avec 1 pour préparer l’affichage d’un entier.
	L’instruction syscall affiche 2 puis $2 est chargé avec 4 pour préparer le prochain affichage.
	Le caractère séparateur ‘-‘ est chargé dans $4 et l’instruction syscall provoque son affichage.
$L18 : incrémentation de 2 à 3 puis retour à $L16
Après l’impression de ‘3 –‘, on incrémente pour passer à 4, qui a été remplacé par 0
dans le tableau. Alors l’instruction 	$L19	blez	$2, $L18	provoque le retour à $L18 sans affichage. On incrémente de 4 à 5 et on continue ainsi de suite.
En résumé, chaque nombre différent de 0 du tableau (c-à-d chaque nombre premier) est affiché avec le caractère séparateur ‘-‘.

3.4 Algorithme équivalent au code assembleur : 

2ème partie : création du tableau des nombres de 2 à 100.
Entier M [  ]					# le tableau des nombres en mémoire
Entier MEM					# l’adresse d’un nombre en mémoire
Entier I						# pour parcourir le tableau
Entier PTR					# le pointeur des variables
PTR 1
Pour I = 2 Jusqu’à 100 Faire
	MEM  (I * 4) + M [PTR] + 16	# création de l’adresse avec déplacement
	M [MEM]  I				# écriture du nombre à l’adresse créée précédemment
FinPour	
	
3ème partie : détection des nombres premiers et « annulation » des autres.
Entier M [  ]					# le tableau des nombres 2 à 100 en mémoire (99 cases)
Entier PTR1, PTR2				# 2 pointeurs sur ce tableau de nombres ; pour simplifier,
						   1<PTR1<99 et 1<PTR2=<99
Entier LO, HI
Pour PTR1 = 1 Jusqu’à 98 Faire
	Pour PTR2 = PTR1+1 Jusqu’à 99 Faire
		Si M [PTR2] <> 0 ET M [PTR1] <> 0 Alors		# si on rencontre un 0 on passe
LO  M [PTR2] % M [PTR1]			# LO est le quotient 
			HI  M [PTR2] / M [PTR1] – LO		# HI est le reste
			Si HI = 0 Alors					# si les nombres sont des multiples
				M [PTR2]  0				# le 2ème est remplacé par un 0
			Finsi
		Finsi
	FinPour
FinPour

4ème partie :affichage
Entier M [  ]					# le tableau des nombres 2 à 100 en mémoire (99 cases)
Entier I						# pour parcourir le tableau
Pour I = 1 Jusqu’à 99 Faire
	Si M [I] <> 0 Alors			# si on rencontre un 0 on passe
Afficher M [I] , ‘-‘			# affiche le nombre premier suivi du caractère séparateur
Finsi
FinPour