scsi.device v43.46 (II)

Bon, Kefrens laisse un message en disant qu'elle n'a rien compris...

Bref, utilisons alors un croquis qui parait-il vaut 1000 mots.

Voici le fonctionnement très simplifié du CPU lorsqu'il demande des données précises à traiter :

Le code cache déjà est une mini-mémoire se trouvant dans le CPU beaucoup plus rapide que la Simm. Ici pour le 68040, elle ne fait que 4 Ko.

La fastram en barrette Simm contient les programmes. Ici, avec notre exemple de trois instructions pesant 6 octets, qui n'est qu'une minuscule partie de notre driver IDE.

Lorsque le programme est exécuté par l'utilisateur, nos 6 octets doivent déjà être transféré de la Simm dans la mémoire cache du CPU. Ce transfert prends un certain temps, et le 68k va attendre jusqu'à ce que ces données arrivent en lui. Ensuite, lorsque nos 6 octets sont enfin dans ce fameux cache, le 68040 va les exécuter : ces trois opérations sont prendre encore un temps certain, qui sont alors appelés cycles CPU.

Maintenant, avec cette partie retravaillée, il n'y a plus que 4 octets : le temps d'attente du CPU pour le transfert dans son code cache est donc moins long (= plus rapide) et ensuite l'exécution ne prends plus que deux cycles au lieu de trois !

Le fonctionnement est un peu plus compliqué en réalité, mais grosso modo c'est ça.

Je pense que c'est plus clair maintenant !

Voici quelques explications supplémentaires quant à l'organisation de la fastram. Elle peut être comparée à un long tube d'une largeur de 32 bits.

Marche arrière avant de continuer.

Nous utilisons tous quotidiennement le mode décimale (base 10 car 10 nombres sont utilisés à savoir le 0, 1, 2, 3, 4, 5, 6, 7, 8 et le 9) sans aucun sigle distinctif.

Le bit est l'unité fondamentale en informatique : tout est construit à partir cette brique. Il peut être soit à 1 ou soit à 0. Il n'a donc que deux possibilités, d'où l'appellation binaire (base 2 car 2 nombres sont utilisés, le 0 et le 1). Le sigle utilisé pour distingué un nombre binaire est %.

Tout est nombre avec tous les CPUs du monde entier : en effet, ils ne comprennent QUE les nombres binaires, et rien d'autre ! Les autres bases (comme la base 16, voir plus loin) vont simplifier la lecture et la compréhension pour les humains.

Ensuite :

• un nombre 8 bits = 1 octet (ou byte en anglais avec pour abréviation .b)
• un nombre 16 bits = 1 mot (ou word en anglais avec pour abréviation .w)
• un nombre 32 bits = 1 long mot (ou long word en anglais avec pour abréviation .l)

Donc 8 chiffres consécutifs précédé du sigle % indique un octet binaire :

• 000000 = 0
• 000001 = 1

Stop : nous avons utilisé tous les chiffres disponible en binaire. Il suffit alors de décalé d'un cran vers à gauche en le mettant à 1 et de remettre à 0 le cran droit :

• 000010 = 2
• 000011 = 3

Ajout de 1 sur un nouveau cran et remise à 0 des autres :

• 000100 = 4
• 000101 = 5
• 000110 = 6
• 000111 = 7

... et ainsi de suite...

• 001000 = 8
• 001001 = 9
• 001010 = 10
• 001011 = 11
• 001100 = 12
• 001101 = 13
• 001110 = 14
• 001111 = 15
• 010000 = 16
• 010001 = 17
• 010010 = 18...

Une autre base est très utilisée en informatique : l'hexadécimal (base 16 car 16 nombres et lettres sont utilisés comme le 0, 1, 2, 3, 4, 5, 6, 7, 8 ,9, A, B, C, D, E et le F). Le sigle $ (ou 0x, 0h, &h) signifie hexadécimal :

• 000000 = 0 = $00
• 000001 = 1 = $01
• 000010 = 2 = $02
• 000011 = 3 = $03
• 000100 = 4 = $04
• 000101 = 5 = $05
• 000110 = 6 = $06
• 000111 = 7 = $07
• 001000 = 8 = $08
• 001001 = 9 = $09
• 001010 = 10 = $0A
• 001011 = 11 = $0B
• 001100 = 12 = $0C
• 001101 = 13 = $0D
• 001110 = 14 = $0E
• 001111 = 15 = $0F

Stop : tous les chiffres et lettres de la base 16 sont utilisés. Cran à gauche additionné de 1 et mise à 0 pour l'autre :

• 010000 = 16 = $10
• 010001 = 17 = $11
• 010010 = 18 = $12...

Revenons à nos moutons maintenant. Il y a une correspondance entre les nombres qu'utilise notre CPU pour fonctionner et les lettres et chiffres utilisés par les hommes pour créer les listings des programmes. Tous les softs que nous utilisons sont une suite de nombres. Le mot 'code' est employé parce que les nombres sont codés d'une certaine façon. Chaque fabricant a la sienne en fonction du processeur. Ici, nous sommes chez Motorola avec les 68k. Le codage est obligatoire pour nos cerveaux humain qui comprends beaucoup mieux les lettres :

• move.b d1,d0     est codé $1001 pour les CPUs 68k
• ext.w d0            est codé $4880 pour les CPUs 68k
• ext.l d0             est codé $48C0 pour les CPUs 68k

Il est plus aisé pour le cerveau de lire et de comprendre par exemple 'move.b d1,d0' que '$1001' ou encore '01000000000001', vous êtes bien d'accord !!

Ensuite le tube mémoire fastram est divisé en adresses qui informent au CPU où est rangé tel ou tel nombre. Pour notre exemple, elle commence à $1000000. Voilà ce que contient notre fastram, des 0 et des 1 simplifiés ici par une notation hexadécimal :

Avec ce schéma, il est très compréhensible de voir qu'un long mot fait quatre octets. Donc pour résumer, notre code est aux adresses :

• $1000000.b => $10 = 010000
• $1000001.b => $01 = 000001
• $1000002.b => $48 = %01001000
• $1000003.b => $80 = %10000000
• $1000004.b => $48 = %01001000
• $1000005.b => $C0 = %11000000

En simplifiant :

• $1000000.w => $1001 = 01000000000001
• $1000002.w => $4880 = %0100100010000000
• $1000004.w => $48C0 = %0100100011000000

Ou alors si vous préférez :

• à l'adresse fastram $1000000 il y a le mot 16 bits $1001 qui décodé en 68k signifie 'move.b d1,d0'
• à l'adresse fastram $1000002 il y a le mot 16 bits $4880 qui décodé en 68k signifie 'ext.w d0'
• à l'adresse fastram $1000004 il y a le mot 16 bits $48C0 qui décodé en 68k signifie 'ext.l d0'

L'assembleur est simple lorsqu'il est bien expliqué depuis le tout début !