Auteur question sur les GPU
HydracolonnaPosté le: 2002-03-07 09:12   
Bonjour, je voudrais savoir quelle différence il y a entre un proc d'ordi et un proc graphique. Pourquoi sont-ils en 256 bits avec une ram en 128 bits ? Qu'est-ce que cela implique les 256 bits ? Pourquoi en 256 et pas en 32 comme les proc d'ordi ? Quelle différence dans le fonctionnement ? Plus rapide ?
La question me viens aussi car je remarque que les proc pour Mac sont en 128 bits et ceux des pc en 32 (sauf pour certains proc pour serveur), or il me semble que plus le proc traite de bits d'un coup plus il est efficace. Pourquoi cette différence ? Merci.

buzzzPosté le: 2002-03-08 04:05   
hum
je tente une reponse,

tout d'abord les procs graphiques sont des procs dedies, cad qu'ils sont specialisees dans le calcul en flottant.

Ainsi en 256 bits, ils entendent en fait (je pense) un calcul parallele sur 32 bits * 8. Soit des operations sur 8 nombres flottants en parallele, et pas un seul nombre de 256 bits. Le proc fait cela aussi avec les instructions SSE mais en 64 bits... mais !! ils y a 8 registres SSE donc 512 bits au final...

La carte graphique etant specialisee uniquement dans cela, elle peut se permettre de cabler sa ram sur 128 bits, et d'occuper la puce de calcul sur les calculs flottants en sur 256 bits. Mais en contrepartie, le memoire ram est de 64 MO

ainsi pour 64 MO et calcul 256 tu paies 2000fr

pour un proc 32/64 bits et 64Mo de RAM tu paies prix Duron 800 + prix barrete128/2 = 400+30 430fr

Ben oui, faut il s'en rendre compte tu paies 5 * plus cher ta puce video... il est normal qu'elle soit en 256 bits

pour avoir un proc 256bits, le duron vaudrait 3000fr et la ram idem... donc voila pourquoi

HydracolonnaPosté le: 2002-03-08 16:46   
Merci, je pense avoir pigé, tu es calé dis-donc !
buzzzPosté le: 2002-03-08 18:24   
pour etre franc, je fais plutot des suppositions par rapport au "peu" que je sais sur le sujet. Je peux me tromper... mais je pense que ca doit tourner autours de cela.

Oui de plus l'interet de monter en 256 bits et de faire du calcul parallele et alors ? pourquoi pas prendre 32 bits avec une frequence 8 * plus elevee !! hors il me semble que les procs actuels 3D ont une frequence de 250Mhz. S'ils etaient donc construit sur une architecture non parallele un seul calcul en flottant par cycle il faudrait qu'il tourne a 250*8 = 2 GHz, avec de la memoire a 133*8 = 1Ghz. Techniquement c'est limite, les procs seraient graves pour du 2ghz ce qui couteraient beaucoup plus cher et ca chaufferait pas possible. De plus la memoire ne suivrait pas cette cadence

donc au final pour eux 256bits c'est comme 8 processeurs 32 bits a 200Mhz

FavernPosté le: 2002-03-08 18:54   
Bonjour buzzz,

Il y a quelques chose que je ne comprend pas bien:

"Tu nous à dit qu'un proc graphique fait un calcul parallele sur 32 bits * 8."

Puis tu nous à dis:
"Le proc fait cela aussi avec les instructions SSE mais en 64 bits... mais !! ils y a 8 registres SSE donc 512 bits au final... "

Et pour finir:
"d'occuper la puce de calcul sur les calculs flottants en sur 256 bits."

Ca signifie quoi physiquement ? Ce que je ne comprend pas c'est que tu face intervenir une notion d'occupation du processeur (software).
Donc avec un processeur aussi on pourrait lui faire occuper ses 512Bits pour faire de la virgule flottante ?

Donc puisque que c'est simplement une différence d'occupation software j'avoue ne pas comprend la différence entre un GPU et un CPU

Favern

buzzzPosté le: 2002-03-08 19:05   
il y a 8 registres SSE de 64 bits
mais on n'a uniquement le droit de faire une operation sur l'un deux a la fois

chacun de ces registres permet cependant de faire un calcul paralle sur deux floats de 32 bits.

il y a 512 bits de registres et seulement un registre utilsable a la fois

pour le GPU, je ne sais pas combien il y a de registres mais, par cycle il travaille sur 256 bits... donc qqc comme 8 en paralle ou plus si ses float sont en 20 bits...


FavernPosté le: 2002-03-08 19:11   
A oui d'accord j'ai comprit. Sauf une petite chose. Tu a dis:
Quote:

Le 2002-03-08 19:05, buzzz a écrit:
pour le GPU, je ne sais pas combien il y a de registres mais, par cycle il travaille sur 256 bits... donc qqc comme 8 en paralle ou plus si ses float sont en 20 bits...


Des float de 20bits ?

Les processeurs travailles souvent à 20 bits ????????

Ca ferait du 20 x 2 x 8 = 320bits ?

Favern

ElbartoPosté le: 2002-03-08 19:34   
interessant ce topic
buzzzPosté le: 2002-03-08 21:34   
...
en fait chacun choisi sa precision... sauf pour l'architecture x86, ou un float fait forcement 32 bits... dans d'autres puces c'est pas toujours le cas, souvent 32 mais aussi 5 de + chez HP et maintenant sur les 3Dnow, ils ont (il me semble) un format reduit

en effet, 23 bits pour les digits 1 pour le signe et 8 pour la mantisse cela fait beaucoup pour la mantisse. Car pour un jeu 3D si tu representes ton repere en cm, tu n'as pas besoin de connaitre les cordonnees a 10^256 cm de la camera, en general les faces au dela de 50m sont effaces donc cela ferait de 0 a 50000m soit un ordre de grander de 10^5, une mantisse 3 bis serait largement suffisante dans ce cas , pareil au niveau de la precision des digits

Inutile de savoir qu'un point se situe a 132cmde toi ou 132.1324354354 cm. donc on peut aussi reduire les 23bits facilement



FavernPosté le: 2002-03-08 21:42   
Bonjour buzzz,

Je t'avoue comprend seulement trés superficielment tout ceci.

Car il me manque toutes les bases sur les processeur.

Juste une question: C'est quoi un registre ?

Favern

buzzzPosté le: 2002-03-10 01:04   
....

effectivement je pensais que pour toi l'electronicien c'etait de l'acquis.

Bon pour expliquer succintement

Sur la pauvre calculette d y a 10 ans, il y avait une touche M+ M- CM RM. Bref une memoire qui stockait un resultat. Quand tu appuyais sur M+ cela ajoutait le resultat affiche a chiffre stocke en memoire et RM : afficher le contenu, CM (clear memory) la remetter a 0.

le processeur ne sait effectuer que quelques instructions types, addition/soustraction */division comparaison saut (goto) eventuellement suivant le resultat d'une comparaison, appel d une sous procedure (CALL, GOSUB...), Transfert d'octet. Toutes les autres fonction sont des sous-cas de celle la. Donc un proc pourrait ne fonctionner qu'en effectuant que des operations sur la memoire, on est bien d'accord. Ainsi on peut ecrire si [2423] designe l'octet a l'adresse 2423 ADD [2423],2. ( [2423]=[2423]+2 ) Malheureusement, ceci mettrait toutes operations dependantes de la bande passante de la memoire, et tous les pcs seraient restes a 133Mhz en clock CPU. La SDRAM a une vitesse 10 * plus rapide qu'un disque dur, le registre est encore 10* rapide d'acces lui que le HD car directement loge dans le proc. En contrepartie ils sont moins nombreux
exemple pour les x86:
DD debit : 30MO/s capacite 30GO
memoire : 133Mo/s capacite 256 Mo
registre : < 1cycle proc capacite 16 octects

dans le chipset des PC il y a 4 registres standard, AX,BX,CX,DX de 32 bits ( 4 * 4 octects = 16). Toutes les commandes du jeu d'instruction s'effectuent entre un registre et une memoire ou une constante : 4, 6 8...

ainsi on ne peut pas trouver
ADD [563],4
ADD [436],[5454]
mais on trouvera
ADD AX,[5454]
ADD [444],AX
ADD AX,8

c'est les herirages de l'architecture intel. D'autres puces existent avec +++ de registres ( + 64 parfois ) et en contrepartie ont un nombre d'instruction machine faible RISC. Les CISC ont par contre beaucoup plus d'instructions mais en contrepartie ont moins de registre.

Cela vient que la taille des instructions du langage est limite a quelques octects. Ainsi pour stocker une instruction stype ADD [444],[444] il faut stocker ADD (1 octect pour 256 instructions), deux adresses sur 32 bits cela ferait 32*2+8 = 72 bits, c'est plus gros que le bus, donc pas faisable rapidement. Donc intel prefere ADD AX,[444] code "ADD AX", comme une instruction et [444] sur 32 bits, ainsi cela fait plus que 40 bits .

Si tu as beaucoup de registre, cela mutiplie le nomnbre d'instructions : ADD numeroregistre,[444], il faudra plus de bit pour stocker le numero du registre et globalement il y aura moins d'instruction au final. Par exemple pour un intel ADD ?X,...
ce code sur 6 bits pour ADD, et 2 bits pour AX,BX,CX et DX.

Bref les 4 registres ont plutot des taches precises, AX resultat de calcul, BX addresse, CX compteur de boucle et DX deuxieme adresse.

en langage machine, ecrire un programme c'est donc comme faire un programme dans un langage quelconque sauf que tu as droit qu'a 4 variables et tous le restent c'est des adresses.

je te laisse digere tout cela

si qqc de flou ne pas hesiter a en redemander

ps il existe bien d'autre registre dans un proc mais tu n'est pas sense les manipuler directement . Ainsi il existent CS et IP qui indique la position dans la memoire de la prochaine instruction a executer. Tu n'es as sense toucher a ce registre toi meme surtout pas,

un dernier detail en memoire tout est bits, je veux dire les instructions machines comme les autres donnees. Ainsi le proc ne sais a quoi il a affaire que par rapport a ce qu'il fait. Ainsi si il doit executer l'instruction qui est a l'adresse xxx, il lira 4 octects a cette adresse et recherchera l'instruction machine correspondante. Si on lui dit d'ajouer a AX le nombre a l'adresse xxx, il considera que xxx est cette fois un nombre et s'en servira pour une addition. Pourtant, a l'adresse xxx il n'y avait que des bits

[ Ce message a été édité par: buzzz le 2002-03-10 01:17 ]

FavernPosté le: 2002-03-10 07:22   
Bonjour Buzzz,

merci pour tout ca. Effectivement je vais digérer tout ca, et aprés je poserais les question si besoin

Au fait je ne suis pas électronicien. Mais plutot électrotechnicien. Donc pour moi c'est plutot les moteurs et les transformateurs.......

Favern

FavernPosté le: 2002-03-10 07:50   
Quote:

Le 2002-03-10 01:04, buzzz a écrit:
le processeur ne sait effectuer que quelques instructions types, addition/soustraction */division comparaison saut (goto) eventuellement suivant le resultat d'une comparaison, appel d une sous procedure (CALL, GOSUB...), Transfert d'octet. Toutes les autres fonction sont des sous-cas de celle la. Donc un proc pourrait ne fonctionner qu'en effectuant que des operations sur la memoire, on est bien d'accord. Ainsi on peut ecrire si [2423] designe l'octet a l'adresse 2423 ADD [2423],2. ( [2423]=[2423]+2 )


Là par contre j'arrive pas à te suivre
Ca arrive souvent que le contenue de la mémoie à le méme nombre que l'adresse ?

Et que signifie le "+2" ?

Quote:

Malheureusement, ceci mettrait toutes operations dependantes de la bande passante de la memoire, et tous les pcs seraient restes a 133Mhz en clock CPU.


Je ne vois pas vraiment pourquoi je t'avoue ?

Quote:

ADD [563],4
ADD [436],[5454]
mais on trouvera
ADD AX,[5454]
ADD [444],AX
ADD AX,8


Oui, mais dans le 1er cas, il y a avait les données. Et maintenant il n'y a plus les données ?

Quote:

Cela vient que la taille des instructions du langage est limite a quelques octects. Ainsi pour stocker une instruction stype ADD [444],[444]


Je ne comprend plus trop non plus. Tu m'as dis au début que le 1er nombre désigné les données et aprés que l'on avais l'adresse non ?
Et maintenant tu me dis que ce sont 2 adresse ?



En fais pour toutes les questions que je t'ai posé jusqu'a maintenant on peu la résumer en:
Pour ce genre d'instruction:
"ADD [444],[444]". Que signifie le 1er chiffre et le second ?


Par contre j'ai bien compris le reste

Merci

Favern

_________________
o----[:::::::::::::>®©

[ Ce message a été édité par: Favern le 2002-03-10 07:50 ]

[ Ce message a été édité par: Favern le 2002-03-10 08:00 ]

buzzzPosté le: 2002-03-11 04:23   
la aussi il s'agit de notation, donc je te la donne :

quand tu ecris un nombre sans autre signe quel que soit l ecriture : octal,decimal ou hexa, cela represente une valeur, au sens un nombre qui va participer a une operation arithmetique.

Des que l'on pose les [], il s'agit alors d'une adresse, et j'ai oublie, [444] designe la valeur contenue dans la case memoire numero 444...

Ainsi
MOV BX,1234 (de droite a gauche toujours, donc 1234 dans BX)
MOV AX,[BX] (et maintenant [1234] dans AX

ainsi le registre AX contient la valeur contenue dans la case memoire 1234.

Alors quand j'ecrit la sequence suivante
MOV AX,[1234];
ADD AX,10;
CMP AX,50 (compare AX a 50)
JE toto (si egal allez a toto)

La premiere instruction est une bloquante, car elle accede a la memoire. Donc le proc attend le bus. Les trois suivantes s'effectuent sur des registres internes au proc, donc ne dependent plus du bus memoire, peuvent etre optimise. Grosso modo, aujourdh'ui elles doivent etre execute en moins d'un cycle, deux au plus.

Bon, alors si tu n'as pas de registre tu es oblige d'ecrire
MOV [1235],[1234]
ADD [1235],10
CMP [1235],50
JE toto

donc la toute tes operations dependent du bus memoire, puisque le proc n'a plus moyen de souvenir d'un resultat, tout chiffre est lue en memoire et le resultat n'est pas stocke dans un registe mais reecrit en memoire... donc a part le jump tout passe par des lectures/ecritures memoire


voila, dis moi ce qui te manques



_________________
perdu dans la thèse ou dans l'espace intergalactique... (depend des jours)

[ Ce message a été édité par: buzzz le 2002-03-11 04:25 ]

kirinPosté le: 2002-03-11 21:08   
Salut Buzzz,

Quote:
pour etre franc, je fais plutot des suppositions par rapport au "peu" que je sais sur le sujet. Je peux me tromper... mais je pense que ca doit tourner autours de cela.



Modeste va ou très bon en suppositions

C tout bon

Amities buzzz

Seb

PS : le fait de construire un processeur 256 bits de large est un pb d'architecture, de surface, de dissipation thermique comme tu l'as dis mais je crois que c aussi un peu un pb d'hyperfréquence... plus les bus sont larges plus ca "bourdonne" et plus il y a risques de pb de parasitages et propagations d'ondes notamment ...

buzzzPosté le: 2002-03-12 02:50   
merci merci

faudra un jour que je fasse mon site web pour expliquer comment marche un pc de maniere a ce que tout le monde puisse comprendre chaque question en 10 minutes maxi...

Quand je regarde certaines personnes, je vois que tous les aspects de l'informatique tirent sur le mythique. Je les comprends moi-meme car tout ce que je ne connais pas encore, je le trouve tordu et bizarre. Pourtant souvent, la simplicite est la, c'est les humaines qui sont compliques...

puis faut penser aux generations futures...

FavernPosté le: 2002-03-12 06:51   
Bonjour,

Oui, merci. Je commance un peu à tout comprendre là

Mais j'ai encore une petite question:
Je sais que tu a dis au début que les processeurs graphiques fond surtout du calcul de virgule flottante.
Mais je ne comprend pas pourquoi les processeurs graphique n'utilisent pas les registres ? Ca pourrait permettre d'économiser de la bande passante non ?

Favern

nicholas_fr2001Posté le: 2002-03-12 07:25   
Quote:

Le 2002-03-12 02:50, buzzz a écrit:

faudra un jour que je fasse mon site web pour expliquer comment marche un pc de maniere a ce que tout le monde puisse comprendre chaque question en 10 minutes maxi...




J'espère que ce jour arrivera vite

TianPosté le: 2002-03-12 09:58   
Salut
Quote:

Le 2002-03-12 06:51, Favern a écrit:
Mais je ne comprend pas pourquoi les processeurs graphique n'utilisent pas les registres ? Ca pourrait permettre d'économiser de la bande passante non ?


Les proc graphiques doivent surement avoir aussi des registres. Mais ceux ci sont en nombre limites pour des raisons technologiques (de prix notemment) Donc pour les grosses donnees que doit stocker une carte graphique, il lui faut une memoire en grande quantite. Celle ci est sous forme de RAM integree sur la carte.

FavernPosté le: 2002-03-12 18:04   
Bonjour,

Euhh Tian: Tu est sur de tout ca ? Puisque là je ne comprend plus vraiment.
C'est en contradiction sur tout le sujet des registres?

De plus si les registres coutent plus cher à fabriquer, pourquoi les processeurs sont moins cher que les processeurs graphique ?

Favern

TianPosté le: 2002-03-12 18:16   
Salut

Qu'est ce qui te gene la dedans Favern? Les GPU sont des processeurs. Ils sont specialises car ils ont des operations de calcul assurees de maniere materielle, donc plus rapidement.

Un registre est un petit bout de memoire integre au processeur en gros (quel qu'il soit). C'est directement dans le meme composant (ou pas tres loin je pense)

La memoire est disticte. Il s'agit d'un element separe, physiquement. Elle peut etre realise par une societe different (c'est d'ailleurs le cas)

En gros, voies ta carte graphique comme une mobo avec son processeur et sa memoire.

FavernPosté le: 2002-03-12 18:31   
Bonjour,

Buzzz nous à expliqué jusqu'a maintenant que ce qui différencié un GPU avec un CPU, est que le CPU comporte des registres contrairement au GPU.

Donc si le GPU comporte également des registres, on retombe à la case départ non ?:
Quelle est la différence entre un CPU et un GPU ?



Favern

TianPosté le: 2002-03-12 18:38   
Je ne vois pas ou buzzz a dit ca

La difference est dans ce qu'il a dit. Des operations cablees materiellement donc plus rapide, une architecture 256 bits,...

FavernPosté le: 2002-03-12 18:40   
Euhh ici:
Quote:

Ainsi en 256 bits, ils entendent en fait (je pense) un calcul parallele sur 32 bits * 8. Soit des operations sur 8 nombres flottants en parallele, et pas un seul nombre de 256 bits. Le proc fait cela aussi avec les instructions SSE mais en 64 bits... mais !! ils y a 8 registres SSE donc 512 bits au final...



Donc d'aprés ce que j'ai compris, le CPU à des registres contrairement au GPU ?

Favern

TianPosté le: 2002-03-12 19:38   
Non, non. Sauf erreur de ma part, buzzz n'a pas voulu dire que les CPU etaient les seuls a avoir des registres. Il disait tout simplement que les processeurs centraux peuvent aussi faire des traitement sur plus de 32bits en parallèle. Cela se fait par le jeu d'instruction SSE qui a ses registres dédiés.

Mais il ne dit pas que les GPU n'ont pas de registre

FavernPosté le: 2002-03-12 20:12   
Bonjour,

Si je peux étre franc, je suis 100% perdu là

Si les GPU utilisent aussi les registres, pourquoi buzzz est partie sur une longue explication de différence entre ca: ADD [563],4 et ca :
ADD AX,[5454] ????????

Favern

_________________
o----[:::::::::::::>®©

[ Ce message a été édité par: Favern le 2002-03-12 20:15 ]

kirinPosté le: 2002-03-12 21:15   
Bonjour,


Je pense qu'il y a des registres dans les GPU mais ils ne sont pas du même type que ceux d'un CPU (aie : ca se complique ! )

Je crois qu'ils sont specialises et leur cablage diffère beaucoup d'un "Registre à usage general" (encore appele couramment GPU pour "General Purpose Register" à ne pas confondre avec GPU pour "Graphic Processor Unit" je sais je suis --> )

Concrètement : leur cablage est certainement plus proche de celui des registres SSE / 3DNow que des "Registre à usage general" d'un CPU.

En fait pour simplifier un GPU ("Graphic Processor Unit") est un gigantesque melange de SSE / 3DNow et autres fonctions *dediees* et cablées.

Ainsi, à la différence d'un processeur, il ne sait pas trop faire 2+3 je pense ... par contre dans certains cas particulier ou il faut faire des millions de fois à la seconde des choses du genre 2/3 ou 2/7 il se debrouilel bien mieux que le dernier P4 2 ghz alors qu'il n'est qu'à 200 Mhz

C le principe même (et ca date) des ASP (Advanced Signal Processor) ou DSP (Digital Signal Processor) qui sont très forts dans des applications très spécifiques mais ne savent faire que ca. Par rapport, un processeur est 100 x plus polyvalent mais au final et en contrepartie dans le cas précis de ce pour quoi les GPU ("Graphic Processor Unit") ont ete optimises il est nettement moins rapide...

NB : les veritables asp et dsp d'epoque n'existent plus tant que cela ils tendent à être remplaces par des ASICS construits à base de PAL, GAL, FPGA et autres equivalents et de leurs bibliothèques. Plus souples, plus simple à concevoir grace aux bibliothèques... plus...

Dernier exemple Qd je commence à parler de l'architecture des système microprogrammes à mes eleves, je leurs dis qu'un coeur de CPU c un ane qui bat très vite des oreilles. Ca ca leur plait bien sur Un peu moins quand j'ajoute qu'ils seront le cerveau de l'ane et que ce sera à eux (leur prog) de rendre l'ane moins bête (là c mon tour de faire un )

Et bien si je devais parler d'un GPU je pense que je dirais que c une tortue capable de sprinter bien plus vite qu'un lièvre à condition de bien la conditionner

Mouais je sais : en cours c un peu folklore de temps en temps mes explications mais bon le programme rentre et c ce qui compte Et autant que cela se fasse dans la bonne humeur si possible.




Seb

[ Ce message a été édité par: kirin le 2002-03-12 21:19 ]

Eviv iomPosté le: 2002-03-12 21:28   
Génial ce topic!!! Moi ça me passionne ce genre de truc. Je connaissais déjà en (très) gros le fonctionnement d'un CPU, mais je ne m'étais jamais penché sur le GPU.

Pour répondre à ta question Favern: a mon avis, Buzz a voulu dire que le CPU d'était pas capable d'ajouter directement à une valeur stockée dans un coin de la RAM une autre valeur. Pour ce faire, il doit obligatoirement copier d'abord le contenu de la case memoire de la RAM dans un registre processeur, ici le registre AX, et ensuite il peut ajouter une autre valeur à celle copiée dans AX. Bien sûr, après il peut recopier la nouvelle valeur stockée dans AX dans une case memoire de la RAM.
Enfin, c'est ce que j'ai crû comprendre...

En fait je pense qu'il faut se représenter le GPU comme un CPU secondaire, spécialisé dans le traitement d'images, auquel le CPU peut dédier des tâches pour avoir les mains libres. Il peut très bien avoir des registres si ça lui fait plaisir... Il peut être comme il veut, tant qu'il marche...


N'empêche que je me demande comment on a fait pour inventer une machine aussi compliquée qu'un PC...



[ Ce message a été édité par: Eviv iom le 2002-03-12 21:38 ]

buzzzPosté le: 2002-03-13 06:10   
j'ai l'impression que je fais bouillir les neuronnes de tout le monde, les miens ont bien bouillu aujourdh'ui (regardez l'heure du post)... bon alors

Pourquoi j'ai parle de registre pendant 4 heures , pour repondre a la question : "qu-est ce qu'un registre . Toute puce un tant soit peu evolue a des registres, CPU et GPU donc oui. Car sans registre il faut sans cesse cabler toutes les actions en acces memoire et pertent de temps. Donc les registres sont la pour stocker des resultats intermediaires sans repasser par la memoire, donc gain de temps.

Les GPU font moins de chose, car globalement tres specialise, donc on peut se permettre de coller des registres en 256 bits pour effectuer des calculs en parralle sur par exemple 8 nombres de 32 bits. Ces fonctionnalites existent deja pour les CPU avec les instructions SSE/3DNow et compagnie... mais cependant les registres nouveaux disponibles pour cela ne sont que des registres 64 bits avec calcul parallelise pour 2 nombre de 32 bits (en general). Donc un GPU 256 bis effectuent grosso modo deja 4* plus de calcul en masse qu'un cpu. Ensuite ne l'oublions pas, quand le GPU calcule, le CPU peut faire autre chose . Car sans GPU, rappelez vous dirextX marche et oui... mais cette fois les rendus 3D tirent sur les registres SSE et le proc passent sont temsp a faire des calculs 3D. Alors qu'il a tant d'autre chose a faire.

De plus ces registres GPU 256 bits, peuvent etre recoupes specifiquement pour effectuer des operations sur les flottants, en general les points (x,y,z) mais aussi pour faire les calculs de couleur et texture, (interpolation lineaire cubique...)
Alors qu'un SSE de CPU ne fera toujours que des * et +. Un GPU peut surement faire des operations groupes en une seule fois style
registre = (registre-constante)^3 ce que ne peut pas faire le processeur sans se casser les dents.

Bon alors pourquoi fav est parti dans le choux... tout simplement pcq il s'est melange dans les memoires je pense. En effet les cartes GPU ont des memoires locales soudees autours du GPU qui fonctionne a des frequences ++++. Donc je pense que tu as du en conclure que finalement les registres ont en avait pas besoin effectivement, on peut dire que si le GPU n'avait pas de registres et qu'il utilisait la RAM rapide ce serait un proc primitif mais aussi efficace que le CPU. Car ram rapide => diminue les temsp de latence lors de l'acces a une valeur en memoire. Et usage de registre => accelere la vitesse des calculs globalement. Donc registre+ram rapide => calcul tres accelere. Ca n'a rien d'incompatible, au contraire c'est complemetaire.

voila...
merci a eviv iom de m'avoir resume succintement et correctement

a+

FavernPosté le: 2002-03-13 06:52   
Bonjour,

J'ai beaucoup de mal là
Quote:

Le 2002-03-13 06:10, buzzz a écrit:
Les GPU font moins de chose, car globalement tres specialise, donc on peut se permettre de coller des registres en 256 bits pour effectuer des calculs en parralle sur par exemple 8 nombres de 32 bits.


Mais les GPU sont déja en 256 bits ? Donc si il y a des registres de 256 bits sur des proc de 256 bits, ca fait qu'il y a qu'un seul et unique registre de 256 bits?

Quote:

Ces fonctionnalites existent deja pour les CPU avec les instructions SSE/3DNow et compagnie... mais cependant les registres nouveaux disponibles pour cela ne sont que des registres 64 bits avec calcul parallelise pour 2 nombre de 32 bits (en general).


Bon alors maintenant ce sont des registres de 64 bits ?
Et c'est quoi cette technique de parallelisation de 2 nombres de 32 bits?
Est ce que par hasard ca ne permet pas à partir d'un nombre mit dans le registre que d'un coté ils prennent ce nombre pour le mettre ^2 et puis en parallé le GPU le met ^3
Puis de faire la somme des 2 par exemple ?

Quote:

Bon alors pourquoi fav est parti dans le choux... tout simplement pcq il s'est melange dans les memoires je pense.


Non, en fait je pense que c'est plutot due à cette phrase que tu a dis:
"Ainsi en 256 bits, ils entendent en fait (je pense) un calcul parallele sur 32 bits * 8. Soit des operations sur 8 nombres flottants en parallele, et pas un seul nombre de 256 bits. Le proc fait cela aussi avec les instructions SSE mais en 64 bits... mais !! ils y a 8 registres SSE donc 512 bits au final..."

Et tu a parlé de registre uniquement pour le CPU. Et donc j'en ai conclu que c'était la différence entre les 2

Merci de ta passiente

Favern

buzzzPosté le: 2002-03-13 07:00   
bon avant d'aller fair dodo... donc

Avant on faisait
MOV AX,[444] et il y avait une valeur dans ce registre

maintenant on peut avoir avec un registre 256 = 8*32

MOV Reg256,[444] charge 32 octects en une fois et Reg256 contient 8 nombres de 32
style en hexa :
Reg256 = 00000002000000020000000200000002000000020000000200000002000000000000002

ensuite je multiplie les 8 nombres tous egaux a 2 par, 8 nombre de 32 bits

00000001000000020000000300000004000000050000000600000007000000000000008

par exemple : MUL Reg256,[555]

et apres le calcul j'obtiens :

Reg256 = 000000020000000400000006000000080000000A0000000C0000000E000000000000010





_________________
perdu dans la thèse ou dans l'espace intergalactique... (depend des jours)

[ Ce message a été édité par: buzzz le 2002-03-13 07:01 ]

FavernPosté le: 2002-03-13 07:30   


Alors dans ton dernier message j'ai absolument rien suivit:
Quote:

Avant on faisait
MOV AX,[444] et il y avait une valeur dans ce registre


Pourquoi avant ? Je croyais que c'était la méthode utilisé pour les registres ?

Quote:

maintenant on peut avoir avec un registre 256 = 8*32


D'accord. Donc si je comprend bien, un registre de 256 bits contient bien 8 registres de 32 bits ?

Quote:

MOV Reg256,[444] charge 32 octects en une fois et Reg256 contient 8 nombres de 32
style en hexa :


Ca y est: je viens de claquer un neurone!!
Les processeurs ne géres que des 0 et des 1, donc comment peux t'il charger de l'exa ?
Et c'est quoi un style ?

En toute franchise j'ai rien comprit à cette phrase

Quote:

ensuite je multiplie les 8 nombres tous egaux a 2 par, 8 nombre de 32 bits
00000001000000020000000300000004000000050000000600000007000000000000008
par exemple : MUL Reg256,[555]
et apres le calcul j'obtiens :
Reg256 = 000000020000000400000006000000080000000A0000000C0000000E000000000000010


?????????????????????????????????????????????

Favern

kirinPosté le: 2002-03-13 08:28   
Salut Favern,


Quote:
D'accord. Donc si je comprend bien, un registre de 256 bits contient bien 8 registres de 32 bits ?



Oui, ou 2 de 64 ou 1 de 256 : c *modulable* en fait et il peut dans le registre 256 bits en construire plusieurs identiques pour un total de 256 bits. Il fait un peu sa sauce.


Quote:
Et c'est quoi cette technique de parallelisation de 2 nombres de 32 bits?



C notamment le principe même du MMX et autres SSE / 3DNow.

Avec ton registre 256 bits tu peux théoriquement et au choix, **simultanément** et par ex :
- Additionner 2 nombres 128 bits avec deux autres nombres 128 bits. (deux fois plus rapide qu'additionner un nombre 256 bits avec un nombre 256 bits puisqu'on en addtionne là deux *simultanément*).
- Additionner 4 nombres 64 bits avec 4 autres nombres 128 bits. (4 fois plus rapide qu'additionner un nombre 256 bits avec un nombre 256 bits puisqu'on en addtionne là 4 *simultanément*).


Quote:
Ca y est: je viens de claquer un neurone!!



Ca y est on l'a eu




Quote:
Les processeurs ne géres que des 0 et des 1, donc comment peux t'il charger de l'exa ?



Effectivement c juste une representation, une notation.

Bonjour se dit bonjour en francais et hello en anglais : deux representations de la même chose en fin de compte .

C un peu pareil. L'humain preferera travailler en hexa car un seul symbole qui correspond à 4 digit. Pour l'humain c plus facile de manipuler :

$F0F0F0

que

%111100001111000011110000



et pour le cpu c pareil : qd tu programmes et tape

$F0F0F0

c "transforme" en

%111100001111000011110000

automatiquement à la compilation.


Favern : après Buzz fait du calcul dans la base binaire donc qd on est pas habitué on est paumé c normal.

Mais chaque chose en son temps. Déjà comprendre le //isme sera une bonne chose et ce qu'est un registre, les speficites d'un GPU et le coup de la representation hexa / binaire. ouch

Après seulement on passera au comptage en binaire si on veut sinon là tu vas peter un neurone et c normal


Amicalement

Seb

kkkavernPosté le: 2002-03-13 12:35   
Quote:

Le 2002-03-13 07:00, buzzz a écrit:


ensuite je multiplie les 8 nombres tous egaux a 2 par, 8 nombre de 32 bits

00000001000000020000000300000004000000050000000600000007000000000000008

par exemple : MUL Reg256,[555]




Si je comprends bien, la valeur

0000000100000002...

est a l'adresse 555 dans le cas present. Ou je me trompe ?

FavernPosté le: 2002-03-13 13:35   
Bonjour,

Merci

Quote:

Oui, ou 2 de 64 ou 1 de 256 : c *modulable* en fait et il peut dans le registre 256 bits en construire plusieurs identiques pour un total de 256 bits. Il fait un peu sa sauce.


Tu voulais sans doute dire, 4 de 64 bits non ?

Donc vous me confirmez bien qu'un registre contient plusieurs registres ?

Quote:

Avec ton registre 256 bits tu peux théoriquement et au choix, **simultanément** et par ex :
- Additionner 2 nombres 128 bits avec deux autres nombres 128 bits. (deux fois plus rapide qu'additionner un nombre 256 bits avec un nombre 256 bits puisqu'on en addtionne là deux *simultanément*).


Si on additionne 2 nombres 128bits avec 2 autres nombre de 128bits, ca signifie que le GPU est à 512bits ????

Quote:

- Additionner 4 nombres 64 bits avec 4 autres nombres 128 bits. (4 fois plus rapide qu'additionner un nombre 256 bits avec un nombre 256 bits puisqu'on en addtionne là 4 *simultanément*).


Si on additionne 4 nombre 64 bits avec 4 nombres 128bits, ca signifie que le proc est à 768bits ???????

Franchement je ne comprend rien du tout. Dans un message précédent buzzz à dit que on ne pouvait pas utiliser les registres en méme temps. Donc comment peux ton faire 2 calculs en méme temps dans 2 registres différent en sachant que l'on utilise 1 seul registre en méme temps ???????????????

Je ne vois pas où est le gain de temps en sachant que l'on fais les calculs l'un aprés l'autre dans des registres différents ???


Bon je vais essayer de faire un bilan pour vous dire exactement ce que j'ai bien comprit. Puisque là je suis de plus en plus perdu.

Donc prenons le cas d'un processeur (GPU et CPU) de registre 256bis, on trouve y trouve 4 registres de 64bits.
Lorsque le proc veux faire un calcul dans un registre, il recoit une commande du style:
ADD AX,[5454]
Donc là il vas chercher les données dans la mémoire à l'adresse 5454 et met les donnés dans le registre AX. (J'appelerais les donnée: (DATA1).
Donc là le registre ce retrouve avec un mot de 64bits.

Maintenant voici ce que je comprend vaguement mais qui ne me parait pas logique du tout:
Par je ne sais quel moyen le mot de 64bits est compressé en 2 mots distinct de 32bits. Chaque mot vas empreinter 2 voies différents. Et par exmple, 1 mot vas étre mit au carré et le second vas étre mit au cube.

Voici ce que j'ai comprit sur le parallélisme. A mon avis sur le dernier point j'ai tout faux, mais ainsi peux étre que ce sera plus clair pour vous afin de savoir ce qui ne vas pas ?


Merci beaucoup

Favern

buzzzPosté le: 2002-03-13 14:28   
houla...
bon on y go


alors tu peux faire une operation entre une valeur registre avec une valeur registre ou memoire ainsi tu peux trouver :
ADD AX,[4444]
ADD AX,BX

effectivement pourquoi pas parler de 8 registres de 32 bits plutot que d'un registre 256 bits... subtil

En fait quand on parle de l'architecture d'un processeur... on parle essentiellement de sa bande passante, vers la memoire et dans ses calculs internes.

Ainsi quand on parle de 256 bits, cela veut dire que par cycle le proc peut charger de la memoire dans un registre 256 bits au total + peut faire des calculs entre des registres tel qu'au final la taille totale des registres est au max 256 bits.

En fait oui, on pourrait se passer d'une ecriture en parallele et ecrire comme au bon vieux temps ( il n'y avait qu'un nombre stocke par registre ) :

Add128 R1,[100]
Add128 R2,[116]

comme le proc est un 256 bits, son architecture garantie que ces deux operations 128 bits seront effectues en 1 cycle au max.

PAR COMMODITE d'ecriture, et pour limiter l'occupation memoire (faut pas oublier que ADD est code quelque part), on va forcer le programmeur a n'appeler que des operations en couple : ainsi
on va appeler R256, un registre 256 bits qui en fait sera (R1,R2)
L'instruction machine sera :
ADD128 R256,[100]
et le proc saura que tu veux faire :
Add128 R1,[100]
Add128 R2,[116]

idem si tu ecris :
ADD32 R256,[100] le proc fera

ADD32 R1,[100]
ADD32 R2,[104]
ADD32 R3,[108]
ADD32 R4,[112]
ADD32 R5,[116]
ADD32 R6,[120]
ADD32 R7,[124]
ADD32 R8,[128]
et R256 = (R1,R2,R3,R4,R5,R6,R7,R8)
au final R1 = R1 + int32 a l'adresse 100

pourquoi ces considerations absolues de //
par commoditer de lecture et pour limiter le nombre d'instructions. Dans le dernier exemple ADD32 R256, remplace 8 instructions au total !! est c'est beaucoup pour un proc mine de rien

buzzzPosté le: 2002-03-13 14:41   
bon c'est pas ca que je cherchais mais une bonne lecture ici :

http://cedar.intel.com/cgi-bin/ids.dll/content/content.jsp?cntKey=Legacy::irtmo_index_12733&cntType=IDS_EDITORIAL

buzzzPosté le: 2002-03-13 14:47   
a lire absolument le tutorial d'intel sur MMX, jamais vu un truc aussi bien fait :

http://www.intel.com/vtune/cbts/mmxintro/download.htm

telechargez et lancer
c'est tres tres bien

bon avec ca t'as pour une semaine fav

Mais apres tu seras incollable

TianPosté le: 2002-03-13 14:58   
Quote:

Le 2002-03-13 14:28, buzzz a écrit:
au final R1 = R1 + int256 a l'adresse 100


Ne nous l'embrouille pas plus va

En fait c'est bien 32 mais pour le nombre d'octets, soit 256 bits (8*32)

Pour comprendre ces histoires de plusieurs registres qui n'en font qu'un, imagine que tu regarde un livre. Tu prends un morceau de carton, dans lequel tu decoupe un petit rectangle, de la hauteur d'une ligne, et de la largeur de 4 caracteres. Tu plaques ce carton sur ta page. Tu ne pourras voir que 4 caracteres a la fois. Et tu devras deplacer 8 fois ce cartons pour lire 32 caracteres.

Si maintenant tu decoupe un rectangle de 32 caracteres, tu les liras les 32 d'un coup. Et a chaque deplacement tu en verras 32 nouveaux.

Mais le texte reste le meme en dessous. Tu peux aussi diviser ton grand rectangle en plusieurs autres petits si tu veux. Par exemple faire a cote 8 rectangles de 4 caracteres. (Ceux ci doivent etre suffisamment proches pour que la separation entre eux ne recouvre pas un caractere)

Remplace la page par la memoire du microprocesseur (que ce soit des registres ou de la RAM, la difference n'est pas importante ici). Remplace les caracteres par les octets memoires. Remplace le deplacement du carton par un cycle d'horloge. Remplace ton oeil par le CPU (ou GPU)

Dans le 1er cas, tu n'as acces qu'a 4 octets a chaque cycle d'horloge. Il s'agit d'un processeur 32 bits (8*4). Dans le second, on a un processeur 256 bits (8*32). Si la fenetre est subdivisee en plusieurs rectangles, on a un traitement parallele. On ne traite pas directement 256 bits a chaque fois, mais plutot 8*32 bits.

Ce concept de poser un carton, un masque est tres important en programmation. La memoire est un ensemble lineaire d'information (du moins dans une architecture de Von Neuman). Quand on y accede, on plaque dessus une structure de plus haut niveau. On parle de "mapper" un emplacement memoire. Dans ce cas la, on pouvait considerer nos bits soit comme des paquets de 32 bits, soit comme des paquets de 256 bits. On peut de meme considerer ce qu'il y a a un certain endroit comme un entier, un caractere, une structure, un objet...

FavernPosté le: 2002-03-13 15:50   
Quote:

Le 2002-03-13 14:28, buzzz a écrit:
Ainsi quand on parle de 256 bits, cela veut dire que par cycle le proc peut charger de la memoire dans un registre 256 bits au total + peut faire des calculs entre des registres tel qu'au final la taille totale des registres est au max 256 bits.


D'accord. Donc il décompose le mot binaire ne plusieurs morceaux égaux non ?

Quote:

comme le proc est un 256 bits, son architecture garantie que ces deux operations 128 bits seront effectues en 1 cycle au max.


Pourquoi vouloir faire 1 opération avec 2 bus à 128bits ?
On aurait aussi put faire 1 à 256bits non?

Quote:

PAR COMMODITE d'ecriture, et pour limiter l'occupation memoire (faut pas oublier que ADD est code quelque part), on va forcer le programmeur a n'appeler que des operations en couple : ainsi
on va appeler R256, un registre 256 bits qui en fait sera (R1,R2)
L'instruction machine sera :
ADD128 R256,[100]
et le proc saura que tu veux faire :
Add128 R1,[100]
Add128 R2,[116]
idem si tu ecris :
ADD32 R256,[100] le proc fera
ADD32 R1,[100]
ADD32 R2,[104]
ADD32 R3,[108]
ADD32 R4,[112]
ADD32 R5,[116]
ADD32 R6,[120]
ADD32 R7,[124]
ADD32 R8,[128]
et R256 = (R1,R2,R3,R4,R5,R6,R7,R8)


Le R signifie quoi là dedans ? Tu vas peux étre me dire que R signifie registre ? Mais pourquoi tu les appels R1, R2..... Je croyais que ca s'appelé AX, BX, CX.....

Quote:

au final R1 = R1 + int32 a l'adresse 100


AIE!!! Un second neurone là
C'est quoi int32 ?????,

Quote:

Dans le 1er cas, tu n'as acces qu'a 4 octets a chaque cycle d'horloge. Il s'agit d'un processeur 32 bits (8*4). Dans le second, on a un processeur 256 bits (8*32). Si la fenetre est subdivisee en plusieurs rectangles, on a un traitement parallele. On ne traite pas directement 256 bits a chaque fois, mais plutot 8*32 bits.


D'accord. Donc on à coupé le mot de 256bits en 8 mots de 32bits.
Et c'est plus simple de traiter 8 mots de 32bits plutot que 1 mot de 256bits ?

Favern

BuggyBoyPosté le: 2002-03-13 16:14   
On rigole bien ici. Allez je vais essayer, si j'ai rien compris on me le dira

Quand tu écris un programme qui manipule des nombres entiers, tu peux décider dans une certaine mesure du nombre d'octets que chaque entier occuppe, en fonction de la grandeur des nombres manipulés.

Si tu manipules des coordonnées d'écran limitées à disons 1600, tu peux utiliser des entiers codés sur 16 bits et tu as de la marge (sur 16 bits on peut coder 2E16=65536 entiers)

Maintenant si tu veux manipuler de très grands entiers, alors 256 bits sont plus indiqués car tu peux alors manipuler des entiers de 0 à 2E256-1

Et donc si tu veux faire beaucoup d'additions d'entiers relativement petits et donc codés sur 16 bits, tu en charges plusieurs en même temps dans un registre de 256 bit et le proc fait toutes les additions en 1 cycle.

Donc pour résumer, l'intéret d'un registre 256, c'est de faire des opérations en parallèle sur des données dont on sait qu'elles peuvent être codées sur un nombre plus réduit de bits.

Ce n'est pas plus simple, mais c'est plus facile à coder que n fois la même opération sur un petit registre et plus rapide à exécuter.

ctrl-alt-delPosté le: 2002-03-13 17:16   
roalala que c'est complexe,

cpu = central processor unit

gpu = graphic processor unit

buzzzPosté le: 2002-03-13 22:56   
fav, jete quand meme un coup d'oeil rapide sur : http://cedar.intel.com/cgi-bin/ids.dll/content/content.jsp?cntKey=Legacy::irtmo_index_12733&cntType=IDS_EDITORIAL

tu y trouveras un schemas de decoupe de registres.

Bon, pour la famille des x86, les registres principaux sont AX,BX,CX,DX effectivement les registres MMX sont appeles MM0,...,MM7 et les registres de calculs flottants sont appeles ST0,...,ST7

MMX que j'appelais (SSE je me suis trompe ) a 8 registres de 64 bits qui servent a faire du calcul en entier. Le copro math a 8 registres ST0 ST7 de 64bits pour effectuer des calculs en double. Il s'agit ici uniquement d'appelation car physiquement parlant ce sont les 8 memes. L'utilisation d'une instruction MMX fait passer les calculs sur ces registres en entier, et une instruction fmul fait passer en flottant. Par contre il faut specifier explicitement la fin d'un calcul MMX par une instruction particuliere. Sinon le processeur repere que les registres utilises en entier deviennent bizaremment utilise par des instructions flottantes et il genere alors une erreur generale de l'ordi. C'est fou ca casse tout. Bon je m'ecarte

Peu importe le nom d'un registre, c'est toujours un registre de bits qui peut representer 1 ou des nombres, nombres sui peuvent etre entiers ou a virgule.

Bon le but du jeu est d'effectuer un maximum de calcul !!! Alors par exemple tu as un ensemble de points dans le plan, coordonnees (x,y) qui representent les sommets de triangle a afficher dans le plan. Si tu veux effectuer une translation du vecteur (16,55) tu dois ajouter le vecteur (16,55) a tous les points de la liste. Donc si tu as 100 points a 2 coordonnees, cela fait 200 nombres et donc 200 additions a faire ? ok

si tu charges la valeur du premier x dans un registre 256 bits... pourquoi pas et 16 dans l'autre

tu vas faire :
MOV Reg256,[x] adresse ou est contenue x en memoire
ADD Reg256,16
MOV [x],Reg256
donc 3 instructions de un cyle chacune donc 3*200 = 600 cycles

(comme Buggy l'a fait remarquer), la taille de tes entiers peut etre code seulement sur 32 bits... ca fait de 0 a 4 million... c'est largemenr suffisant pour representer une coordonnees sur l'ecran de resolution 1600 !! bon alors tu peux charger dans ton registre 256 bits 8 valeurs de 32 bits, donc par exemple

MOV Reg256,[adresse]
Reg256 contient par exemple 4 coordonnees de points : x1 | y1 | x2 | y2 | x3 | y3 | x4 |y4
tu as dans un deuxieme registre 4 fois le vecteur deplacement stocke :
Reg'256 = 16 | 55 |16 | 55 |16 | 55 |16 | 55

tu fais ADD Reg256,Reg'256
et tu obtiens en resultats :

points : x1+16 | y1+55 | x2+16 | y2+55 | x3+16 | y3+55 | x4+16 | y4+55
et tu fais un MOV [adresse],Reg256

bon alors au final tu auras

MOV Reg256,[adresse]
ADD Reg256, Reg'256 (ou directement la constate a la place de Reg'256)
MOV [adresse],Reg'256

Tu fais le meme deroulement MOV,ADD,MOV mais cette fois tu aurais effectuer 8 addtions en 3 cycles au lieu de 1 !! La precision est moindre mais en s'en fout. Donc le calcul mettra 3*200/8 = 75 cycles.

si tu fais des calculs sur des nombres entier en 256 bits, alors qu'ils ne prennent que des valeurs entre 0 et 100, cela revient a n'utiliser que les 7 premiers bits du registres 256 et les autres seront toujours a zero. Donc bof autant redecouper les 256 en paquet capable de stocker les entiers que l'on utilise


idem avec les flottants, un flottant 256 bits correspond a par exemple 60 chiffres. Donc si tu veux code la plage 000,000 a 999,999 tu vas utiliser beaucoup moins de bits

Seuls reellement 6 sont utiles

bon essaye de faire le point, j'ai l'impression qu'on te perd la, Kirin code bleue, amene les electrodes.


FavernPosté le: 2002-03-14 13:59   
Bonjour Buzzz,
Quote:

Le 2002-03-13 22:56, buzzz a écrit:
fav, jete quand meme un coup d'oeil rapide sur : http://cedar.intel.com/cgi-bin/ids.dll/content/content.jsp?cntKey=Legacy::irtmo_index_12733&cntType=IDS_EDITORIAL

tu y trouveras un schemas de decoupe de registres.


Donc j'ai été voir la page, mais je n'ai pas trouvé de schéma explicant la découpe d'un registre ?

A moins que c'était le schéma:

Alors en toute franchise ca ne m'a pas du tout aidé.

Quote:

Bon, pour la famille des x86, les registres principaux sont AX,BX,CX,DX effectivement les registres MMX sont appeles MM0,...,MM7 et les registres de calculs flottants sont appeles ST0,...,ST7

MMX que j'appelais (SSE je me suis trompe ) a 8 registres de 64 bits qui servent a faire du calcul en entier. Le copro math a 8 registres ST0 ST7 de 64bits pour effectuer des calculs en double. Il s'agit ici uniquement d'appelation car physiquement parlant ce sont les 8 memes. L'utilisation d'une instruction MMX fait passer les calculs sur ces registres en entier, et une instruction fmul fait passer en flottant. Par contre il faut specifier explicitement la fin d'un calcul MMX par une instruction particuliere. Sinon le processeur repere que les registres utilises en entier deviennent bizaremment utilise par des instructions flottantes et il genere alors une erreur generale de l'ordi. C'est fou ca casse tout. Bon je m'ecarte


Euhhhhh oui.
J'ai lue plusieurs fois ce passage et maintenant mon docteur m'a interdit de le lire une nouvelle fois

Quote:

Bon le but du jeu est d'effectuer un maximum de calcul !!! Alors par exemple tu as un ensemble de points dans le plan, coordonnees (x,y) qui representent les sommets de triangle a afficher dans le plan. Si tu veux effectuer une translation du vecteur (16,55) tu dois ajouter le vecteur (16,55) a tous les points de la liste. Donc si tu as 100 points a 2 coordonnees, cela fait 200 nombres et donc 200 additions a faire ? ok



Oui oui. Jusque là ca vas

Quote:

si tu charges la valeur du premier x dans un registre 256 bits... pourquoi pas et 16 dans l'autre


Pourquoi tu parles d'un registre 256bits ? Tu à combien de registre 256 bits ? Je croyais que l'on été avec des processeurs graphique à 256 bits?
Donc on doit avoir qu'un seul registre de 256 bits ?
Puisque 1 x 256bits= 256bit non ?

Quote:

tu vas faire :
MOV Reg256,[x] adresse ou est contenue x en memoire
ADD Reg256,16
MOV [x],Reg256
donc 3 instructions de un cyle chacune donc 3*200 = 600 cycles

(comme Buggy l'a fait remarquer), la taille de tes entiers peut etre code seulement sur 32 bits... ca fait de 0 a 4 million... c'est largemenr suffisant pour representer une coordonnees sur l'ecran de resolution 1600 !! bon alors tu peux charger dans ton registre 256 bits 8 valeurs de 32 bits, donc par exemple

MOV Reg256,[adresse]
Reg256 contient par exemple 4 coordonnees de points : x1 | y1 | x2 | y2 | x3 | y3 | x4 |y4
tu as dans un deuxieme registre 4 fois le vecteur deplacement stocke :
Reg'256 = 16 | 55 |16 | 55 |16 | 55 |16 | 55

tu fais ADD Reg256,Reg'256
et tu obtiens en resultats :

points : x1+16 | y1+55 | x2+16 | y2+55 | x3+16 | y3+55 | x4+16 | y4+55
et tu fais un MOV [adresse],Reg256

bon alors au final tu auras

MOV Reg256,[adresse]
ADD Reg256, Reg'256 (ou directement la constate a la place de Reg'256)
MOV [adresse],Reg'256

Tu fais le meme deroulement MOV,ADD,MOV mais cette fois tu aurais effectuer 8 addtions en 3 cycles au lieu de 1 !! La precision est moindre mais en s'en fout. Donc le calcul mettra 3*200/8 = 75 cycles.



Bon d'accord. Je comprend à peu prés le principe.
Mais j'ai quelques question:
Comment le proc fait la différence entre 8 mot de 32 bits et 1 mot de 256bits ?

De plus, pourquoi la précision est réduite ? A la fin on obtient le méme résultat non ?

Quote:

si tu fais des calculs sur des nombres entier en 256 bits, alors qu'ils ne prennent que des valeurs entre 0 et 100, cela revient a n'utiliser que les 7 premiers bits du registres 256 et les autres seront toujours a zero. Donc bof autant redecouper les 256 en paquet capable de stocker les entiers que l'on utilise


Oui: Je suis 100% d'accord.

Quote:

idem avec les flottants, un flottant 256 bits correspond a par exemple 60 chiffres. Donc si tu veux code la plage 000,000 a 999,999 tu vas utiliser beaucoup moins de bits


C'est quoi au fait le principe des nombres flottants ?

Quote:

bon essaye de faire le point, j'ai l'impression qu'on te perd la, Kirin code bleue, amene les electrodes.


Bien oui, c'est vrai que là effectivement vous étiez un train de me perdre. Mais ca commence à aller mieux. Anfin, il y a toujours des petites choses que je n'arrive pas à comprendre.

Et une derniére petit chose:
Pourquoi avant tu parlais de "ADD AX,[4444]" et que maintenant tu dis: "ADD Reg256,16" ???????


Merci.

Favern

_________________
o----[:::::::::::::>®©

[ Ce message a été édité par: Favern le 2002-03-14 14:03 ]

buzzzPosté le: 2002-03-14 14:35   
bon.........

une puce 256 bits designe une ARCHITECTURE 256 bits, ce qui veut dire (je l'ai deja ecrit) que le proc arrive a manipuler 256 bits par cycle....

cad
le bus de la memoire est equivalent a un 256 bits, et a l'interieur du proc, il y a PLUSIEURS REGISTRES, d'une taille maximale pour chacun de 256 bits. Ainsi charger une valeur de registre a registre ou memoire a registre prend un cyle en architecture 256 bits.

POUR INTEL :
En architecture 8 bits les registres sont al,bl,cl,dl (abrege de ax low, bx low....), en architecture 16 bits ce sont AX,BX,CD et DX (registres de 16 bits) et actuellement en architecture 32 bits : EAX,EBX,ECX, EDX (extended AX..)


En architecture intel les instructions suivantes existantes :

MOV AX,BX // charger le contenue de AX dans BX
MOV AX,[444] // charger 4 octects a partir de l'adresse [444]
MOV AX,4 // mettre 4 dans AX

pour resumer on caracterise les operations precedentes par les types de variables qu'elles font intervenir :
MOV AX,BX : reg/reg
MOV AX,[444] : reg/mem
MOV AX,4 : reg/constante

ce sont les trois types fournies par l'architecture intel
reg/mem existe evidement dans l'autre sens
mem/reg : MOV [444],AX

Les proc MMX, ont 8 registres 64 bits de plus. MM0,..., MM7 mais quand tu effectues le chargement de ces registres MMX a partir de la memoire, le proc restant une architecture 32 bits en ce moment, le delai sera de deux cycles. Neanmoins, en interne l'architecture MMX est 64, donc les manips reg/reg MMX se font en un cycle.

Comment le proc fait la difference pour savoir si on fait des calculs en entier 64 bits, 2 entiers 32 ou 4 entiers 16 ou 8 entiers 8 sur les registres MMX ?

c'est simplement TOUTES les instructions machines qui sont crees pour CHAQUE CAS.

Si tu veux charger 8 entiers 8 bits a l'adresse x tu ecriras :
LOAD8 MM0,[x]
si tu veux charger 2 entiers 32 bits a l'adresse x
LOAD32 MM0,[x]

Si tu veux faire DEUX additions 32 bits // entre deux registres MMX
ADD32 MM0,MM1

Si tu veux faire QUATRE additions 16 bits // entre deux registres MMX
ADD16 MM0,MM1

Il faut bien comprendre que toutes ces instructions sont codees en memoire par des CODES DIFFERENTS, il existe donc un code pour chaque utilisation :

LOAD8, LOAD16, LOAD32, LOAD64
ADD8, ADD16, ADD32, ADD64



les flottants grosso modo :
tu ecris un nombre : 654654,5464
tu le reecris sous la forme 0,.... 10^?

ici : 0,6546545464.10^6

tu codes le signe sur un bit
tu codes l'exposant de 10 (la mantisse) sur un entier 8 bits, donc de 10^-128 a 10^128
et le nombre apres la virgule est code comme un bon vieux nombre entier sur 23 bits
23+8+1 = 32

voila


Avant que tu poses la question, il existe donc les intructions suivantes :

MOV AL,[44] c'est un MOV8
MOV AX,[44] un MOV16
MOV EAX,[44] un MOV32

mais attention dans ce cas ce n'est pas un chargement parallele

par le fait de la compatibilite ascendante
les 8 bits de AL sont les 24 a 31 de EAX
les 16 bits de AX sont les bits 16 a 31 de EAX

quand tu fais MOV AX,[44] les bits 0...15 de EAX n'ont plus de sens






_________________
perdu dans la thèse ou dans l'espace intergalactique... (depend des jours)

[ Ce message a été édité par: buzzz le 2002-03-14 14:36 ]

[ Ce message a été édité par: buzzz le 2002-03-14 14:42 ]

[ Ce message a été édité par: buzzz le 2002-03-14 14:43 ]

TianPosté le: 2002-03-14 14:46   
Salut
Quote:

Le 2002-03-14 13:59, Favern a écrit:
Donc j'ai été voir la page, mais je n'ai pas trouvé de schéma explicant la découpe d'un registre ?

A moins que c'était le schéma:

(snip)

Alors en toute franchise ca ne m'a pas du tout aidé.


Mon explication avec le carton non plus?

Quote:

Pourquoi tu parles d'un registre 256bits ? Tu à combien de registre 256 bits ? Je croyais que l'on été avec des processeurs graphique à 256 bits?
Donc on doit avoir qu'un seul registre de 256 bits ?
Puisque 1 x 256bits= 256bit non ?


Dire q'un processeur est en 256 bits signifie qu'il va manipuler des donnees de tailles 256 bits. Mais on peut tres avoir plusieurs registres de cette taille. Dans un processeur Intel 16bits, on a plusieurs registres de 16bits (AX,BX,CX,Saxo eeuuhh non oublie le dernier )

Quote:

Comment le proc fait la différence entre 8 mot de 32 bits et 1 mot de 256bits ?


Il ne la fait pas reellement. C'est le programme qui lui dit. Pour lui une valeur est designee par une adresse dans les parametres de l'instruction. L'instruction elle meme dit combien de bits il faut prendre en compte a partir de cette adresse. Tu auras par exemple:

ADD8 R1,[1000]

qui ajoutera les 8 1ers bits de R1 aux 8 1ers bits a l'adresse memoire 1000

ADD16 R2,[1000]

qui ajoutera les 16 1ers bits de R1 aux 16 1ers bits a l'adresse memoire 1000

C'est l'instruction qui le precise. Par defaut sur un processeur 32 bits par exemple, cela se fait sur 32 bits. Et il y a des instructions particulieres pour dire de n'en considerer qu'une sous partie ou pour au contraire en prendre plus.
Quote:

C'est quoi au fait le principe des nombres flottants ?


En memoire, seul sont stockes des nombres. Et ceux ci le sont sur une taille "fixe" Soit sur 32 bits ou 64 ou .... La virgule elle meme n'est pas stockee.

Il y a donc 2 conventions qui existent: La virgule fixe et la virgule flottante.

En virgule fixe, on dit que les x 1ers bits correspondent a la partie entiere et que les y bits suivants correspondent a la partie decimale. Avec x+y=taille totale du nombre.

Par exemple sur un processeur 32 bits, on peut decider d'avoir 20 bits pour la partie entiere et 12 pour la partie decimale.

En virgule flottante, on se sert en fait de la notation exponentielle, appellee scientifique sur les calculatrices, de la forme, par exemple:

-254e+3 = -254 * 10^3 = -254 000

On a la mantisse qui est ici 245, et l'exposant qui est 3. Si l'exposant est negatif, on a des nombres a virgule.

Sur 32 bits, on peut decider d'avoir 20 bits pour la mantisse, 1 pour le signe et 11 pour l'exposant (il me semble que pour les flottants on a un bit de signe et pas un complement a 2, ce qui permet de coder NAN=Not A Number, a verifier...)

Le nombre de chiffres apres la virgule ne sera pas toujours le meme

123e-2 = 1.23 a 2 chiffres apres la virgule
456e-1 = 45.6 a 1 chiffre apres la virgule

C'est pour cela que l'on parle de virgule flottante. Mais la valeur en memoire est quand meme toujours decoupee en champ de tailles fixes.

Courage Favern

_________________
Plutot que de donner a quelqu'un du poisson Linux ne t'apportera que du bonheur, apprends lui a pecher Linux est l'OS ultime.

Signature avec des vrais morceaux de messages subliminaux

[ Ce message a été édité par: Tian le 2002-03-14 14:50 ]

TianPosté le: 2002-03-14 14:51   
Il faudrait mettre en place sur le forum un systeme qui verouille un topic quand quelqu'un est deja en train de donner la meme reponse que celle qu'on fait ca m'aurait economise mes petits doigts
FavernPosté le: 2002-03-14 15:36   
Bonjour,

Je commence un peu à comprendre:)

Mais j'ai encore une question:

Avant buzzz tu parlais de ce type d'instruction:
"MOV AX,[444]"
Puis aprés tu a dis que les instructions étaient du type:
"MOV Reg256,[adresse]".
C'est quoi la différence entre les 2 ?

Tian> Lorsque tu dis :"ADD8 R1,[1000]"
Que représente le R1 ? C'est le registre 1 ?
Et si c'est effectivement le registre, tu parles du registre de 256bits ou du petit de x bits ?

Pour revenir à la virgule flottante, qu'est ce que vous appelez une mantisse ?
Puisque j'ai comparé vos 2 texte et j'ai pas l'impression que vous parlez de la méme chose ???????

Quote:

"MOV AL,[44] c'est un MOV8
MOV AX,[44] un MOV16
MOV EAX,[44] un MOV32


Euhh pourquoi ? C'est quoi un MOV8 ?
Tu m'as parlé de MOV [adresse] mais là je ne te suis plus du tout

Quote:

mais attention dans ce cas ce n'est pas un chargement parallele
par le fait de la compatibilite ascendante
les 8 bits de AL sont les 24 a 31 de EAX
les 16 bits de AX sont les bits 16 a 31 de EAX
quand tu fais MOV AX,[44] les bits 0...15 de EAX n'ont plus de sens "


Tiens. J'ai perdu un neurone.


En tout cas, je trouve que tout ceci est trop abstrait

Favern

TianPosté le: 2002-03-14 15:58   
Quote:

Le 2002-03-14 15:36, Favern a écrit:
Avant buzzz tu parlais de ce type d'instruction:
"MOV AX,[444]"
Puis aprés tu a dis que les instructions étaient du type:
"MOV Reg256,[adresse]".
C'est quoi la différence entre les 2 ?

Tian> Lorsque tu dis :"ADD8 R1,[1000]"
Que représente le R1 ? C'est le registre 1 ?
Et si c'est effectivement le registre, tu parles du registre de 256bits ou du petit de x bits ?


C'est a chaque fois juste des exemples que l'on donne Dans tel processeur les registres s'appellent RA, RB, RC,...; dans un autre AX, BX, CX,...; ailleurs R1, R2, R3,...

Quand buzzz l'a appele Reg256 c'est juste pour signifier qu'il s'agit d'un registre 256bits. Dans mon exemple je l'ai appele R1 comme j'aurais pu l'appeler toto Les registres ont une taille donnee par l'architecture du proc. Sur un processeur 32 bits, il seront en 32bits. Dans mon exemple, on ne considere que les 8 bits de ce processeur (comme en y mettant le carton) mais ca correspond a un seul empladement memoire (la page) Il n'y a pas de petit ou de grand registre, c'est juste que l'on en utilise qu'une partie, ou qu'on en concatene plusieurs.
Quote:

Pour revenir à la virgule flottante, qu'est ce que vous appelez une mantisse ?
Puisque j'ai comparé vos 2 texte et j'ai pas l'impression que vous parlez de la méme chose ???????


buzzz a fait une petite erreur, tu ne vas pas lui en tenir rigueur La mantisse est ce qui se trouve avant le 'e' dans la notation exponentielle.
Quote:

Euhh pourquoi ? C'est quoi un MOV8 ?
Tu m'as parlé de MOV [adresse] mais là je ne te suis plus du tout


Un MOV8 c'est un MOV (affectation d'une valeur) mais en ne considerant que 8 bits. C'est ce que l'on disait comme quoi c'est l'instruction qui decide de la taille a prendre en compte.
Quote:

Tiens. J'ai perdu un neurone.


Ah je l'ai retrouve par terre. Euh dans l'eta ou il est, oublie je crois, il est bon a jeter
Quote:

En tout cas, je trouve que tout ceci est trop abstrait


Il faut programmer (de preference en assembleur) pour vraiment comprendre un peu mieux ca.

_________________
Plutot que de donner a quelqu'un du poisson Linux ne t'apportera que du bonheur, apprends lui a pecher Linux est l'OS ultime.

Signature avec des vrais morceaux de messages subliminaux

[ Ce message a été édité par: Tian le 2002-03-14 15:59 ]

buzzzPosté le: 2002-03-14 19:14   
AX est effectivement le nom de bapteme du premier registre du proc chez intel...

Tu peux l'appeler R1, A1, A, c'est pareil, phyqsiquement parlant c'est toujours le meme, le reste c'est de l'appelation

R8,Reg8 designe (UN) un des registres du proc, mais un registre 8 bits, idem R16,Reg16,R32,Reg32

tous les registres sont equivalents au niveau efficacite, donc c'est pour cela que parfois on ne les distingue pas

idem un MOV8 designe un MOV sur 8 bits, entre un registre 8 bits et un autre registre 8 bits (ou une valeur 8 bits stokee en memoire).

idem pour MOV EAX,??? MOV EBX,??? MOV EDX,???
on peut dire qu'il s'agit un MOV32 sur un registre 32

Mais une machine qui a 200 registres, tu ne vas pas parler d'un registre en particulier, donc tu parleras d'une operation en 32 bits sur registres 32.

il s'agit ici de notation, et ps vraiment d'abstraction


_________________
perdu dans la thèse ou dans l'espace intergalactique... (depend des jours)



[ Ce message a été édité par: buzzz le 2002-03-14 19:18 ]

FavernPosté le: 2002-03-14 19:38   
Bonjour,

Bon voyons si j'ai bien compris:

J'ai un processeur 256bits.

J'ai 8 mots binaire de 32 bits à lui faire rentrer.
Donc je vais rentrer l'instruction:
LOAD32
Et là il vas me créer 8 registres de 32 bits qui sont appelé (AX,BX,CX,DX,EX,FX,GX,HX)
Donc pour les remplir les uns aprés les autres avec des données je rentre:
ADD AX,[1001]
ADD BX,[1002]
ADD CX,[1003]
ADD DX,[1004]
ADD EX,[1005]
ADD FX,[1006]
ADD GX,[1007]
ADD HX,[1008]

Donc là mon registre sera remplie et je peux effectuer mes calculs.


Puis avec le méme proc je veux faire des calculs en 64bits.
Donc je vais rentrer l'instruction:
LOAD64
Et là il vas me créer 4 registres de 64 bits (AX,BX,CX,DX).
Donc pour les remplir les uns aprés les autres je rentre:
ADD AX,[1011]
ADD BX,[1012]
ADD CX,[1013]
ADD DX,[1014]
Donc là mon registre sera remplie et je de nouveau effectuer effectuer mes calculs.

Donc est ce que j'ai bon ?

Favern

_________________
o----[:::::::::::::>®©

[ Ce message a été édité par: Favern le 2002-03-14 19:38 ]

buzzzPosté le: 2002-03-14 21:46   
aie non tu te melanges

ce que tu n'as pas saisi est que les registres sont polymorphes , ils s'adaptent a la demande.

Ainsi sur une architecture 256, tous les registres seront en 256 bits, mais un registre 256 peut a la demander se comporter comme 8 registres de 32.

Ainsi ce que tu voulais faire avec

LOAD32
ADD AX,[1001]
ADD BX,[1002]
ADD CX,[1003]
ADD DX,[1004]
ADD EX,[1005]
ADD FX,[1006]
ADD GX,[1007]
ADD HX,[1008]

s'ecrit tout simplement
ADD32 AX256,[1001]

La decoupe est psychologique si tu veux, le registre c'est un regroupement de bits qui sont physiquement symbolises par des bascules 0,1. Ces bascules restent ordonnees de 0 a 255 quelque soit qui se passe. Neanmoins suivant l'intruction utilisee pour le calcul ADD32, ADD64, ADD128 et ADD256 , les valeurs des bascules sont aiguilles differement dans les circuits de calcul (exactement comme un aiguillage). Ainsi les parties du circuit qui effectuent le calcul sont differentes, le registre est le meme.

Electroniquement parlant

si tu as deux registres de 2 bits A et B
tu peux cabler un calcul d'addition sur A et B

electroniquement si on note, .1 et .2 les bits 1 et 2 des registres, le circuit de calcul va donner qqc dans le genre :

bit 1 resultat = A.1 XOR B.1
bit 2 resultat = A.2 XOR B.2 XOR ( A.1 AND B.1)

Rappel : AND(0,0)=AND(1,0)=AND(0,1)=0 AND(1,1)=1
XOR(0,0)=XOR(1,1)=0, XOR(1,0)=XOR(0,1)=1

conversion decimal=>binaire
0 : 00, 1 : 01, 2 : 10, 3 : 11
(le bit 1 si positionne vaut 1, et le bit 2 : 2, le bit 1 est a droite)

pour comprendre il suffit de voir que XOR sert a culculer une addition bit a bit, et le AND sert a calculer la retenue

ca c'est le calcul en architecture 2 bits sur une valeur 2 bits

mais tu peux utiliser un autre circuit de calcul et effectuer le calcul suivant :

bit1 res = A.1 XOR B.1 (= A.1+B.1)
bit2 res = A.2 XOR B.2 (= A.2+B.2)

ici c'est deux additions sur un bit effectuee en parallele sur le registre de deux bits...

je te conseillerais serieusement de prendre une feuille de papier et de faire l'exercice, ca te permettrait de comprendre.



_________________
perdu dans la thèse ou dans l'espace intergalactique... (depend des jours)

[ Ce message a été édité par: buzzz le 2002-03-14 21:49 ]

[ Ce message a été édité par: buzzz le 2002-03-14 21:51 ]

FavernPosté le: 2002-03-14 22:51   
Bonjour,

Quote:

Ainsi sur une architecture 256, tous les registres seront en 256 bits, mais un registre 256 peut a la demander se comporter comme 8 registres de 32.


Et lorsqu'il ce partage, il ne créé pas de nouvelle adresse du style AX, BX, CX.... ?

Quote:

bit1 res = A.1 XOR B.1 (= A.1+B.1)
bit2 res = A.2 XOR B.2 (= A.2+B.2)


Tu veux m'annener où en fesans tout ces exemples ?
Puisque en plus là ca m'étonne un peu je t'avoue car tu me dis que XOR = OU ???

Donc j'ai essayé de faire l'exemple ne fesant un logigrame. Mais ca ne m'aide pas beaucoup ?


Au fait pour revenir à la virgule flottante,
Donc si j'ai compris ce serait due au fait que parfois les nombres on 4 chiffres aprés la virgule et parfois seulement 1 par exemple ? C'est bien ca ?

Merci beaucoup.

Favern

buzzzPosté le: 2002-03-14 23:26   
XOR n'est pas ou, mais eXcluse OU, cad il ne vaut 1 que si seulement un des deux bits est a 1. Contrairement a OU qui vaut 1 si les deux bits sont a 1.

OUI xor code l'addition sur 1 bit, regarde

0 + 1 = 1, 0 + 0 = 1 et 1 + 0 = 1...

1+1 est faux mais c'est normal, car l'addition n'est pas possible sur un bit car il y a depassement car 1 + 1 = 10 en binaire et tu ne peux stocker 10 dans un bit

donc XOR c'est l'addition

AND c'est la retenue, en effet, 1+1=10 et il y a effectivement retenue


L'interet, construire l'electronique d'un processeur 2 bits a calcul parallele en 1 bit c'est tout

ca devrait t'aider car normalement si tu sais le construire... tu est capable de le comprendre.


FavernPosté le: 2002-03-15 06:34   
Bonjour,

Oui oui, je connais le principe du Xor.
Mais tu me dis:
A.1 XOR B.1 (= A.1+B.1)

Donc là je comprend que Xor = +

Et comment tu veux que je te le construit ? En logigrame ?
Donc là je viens de te faire:
bit1 res = A.1 XOR B.1
bit2 res = A.2 XOR B.2


Mais en toute franchise ca ne m'aide pas vraiment ?

Favern


TianPosté le: 2002-03-15 09:52   
Salut

Voici la table du XOR:
Code:

XOR | 0 | 1
-----+-----+-----
0 | 0 | 1
-----+-----+-----
1 | 1 | 0


Ce qui correspond au + (dans le sens addition et pas OU logique)

En binaire

0+0=0 (naaan pas la tete a toto )
0+1=1
1+0=1
1+1=10

Ca nous donne bien le bit de poids faible (le + a droite avec un XOR. Le seul probleme est que l'on a une retenue. Quand ca? Quand les 2 bits que l'on ajoute sont a 1, c'est a dire (A.1 AND B.1). C'est pour cela que c'est ajoute a la somme des 2eme bits.

FavernPosté le: 2002-03-15 15:18   
Bonjour,

A oui d'accord.
Mais alors pour l'exemple c'est quoi exactement que je dois faire ?

Au fait pour revenir à la virgule flottante,
Donc si j'ai compris ce serait due au fait que parfois les nombres on 4 chiffres aprés la virgule et parfois seulement 1 par exemple ? C'est bien ca ?

Favern

TianPosté le: 2002-03-15 16:05   
Pour l'exemple, ce que tu as cable la, c'est un processeur qui effectue 2 operations 1 bits en parallele sans gerer la retenue. Il n'y a pas de correlation entre les operations et les resultats sur les bits 1 et les bits 2.

Pour avoir des calculs sur 2 bits, il faut que ton 2eme XOR soit a 3 entrees, la 3eme provenant d'une porte AND entre A.1 et B.1

Je n'ai pas trop le temps (ni le talent ) pour me lancer dans des schemas, alors j'espere que c'est assez clair.

Pour la virgule flottante, c'est une maniere de noter differente de celle a virgule fixe. En fait dans ce cas la on se soucie peu du nombre de chiffres apres la virgule. Dans le cas de la virgule fixe, on dit qu'un nombre doit avoir toujours x chiffres apres la virgule. Eventuellement les n derniers peuvent etre a 0, permettant alors d'avoir des nombres a x-n chiffres apres la virgule. Cela fait perdre des chiffres significatifs

Le codage en virgule flottant est plus efficace pour cela, car il ne garde que des nombres significatifs. En quelque sorte... Car n'oublions pas que la mantisse est codee sur un nombre fixe de bits, donc pour les 0 au debut on ne peut rien y faire.

buzzzPosté le: 2002-03-15 16:10   
virgule flottante : des fois tu ecris en million, en centaine, des fois avec beaucoup de chiffre apres la virgule, des fois sans, donc avec l'ecriture en 0,xxx.10^X on se ramene toujours a un nombre compris entre 0 et 1, que l on multiplie apres par 10^X


pour l'exo

Tu as donc deux registres A et B, tu as deux ciruits avec des portes logiques qui te calculent soient une addition sur 2 bits ou 2 additions en // sur un bit. Ca dans un proc c'est la partie memoire et calcul. Il y a aussi la partie commande. La partie commande lit les codes machines en memoire les decryptent et selectionne le/les registres qui vont entrer en jeu et le circuit de calcul qui va etre utilise.

On parle en cycle CPU, signal carre avec front montant et front decedant.

Le cycle T-1, le proc a lu dans la memoire l'instruction suivante a executer. Par exemple ADD1 A,B (2 additions paralleles de
1 bits avec resultat sotcke dans A)

A l'instant T, sur le front montant de l'horloge, il active les portes logiques du circuit dont tu as donne le schemas. Il connectent les valeurs des registres A et B aux entrees du circuit (il ne s'agit ici que de porte qui s'ouvrent commme des interrupteurs). Sur le front haut du signal carre, les petits electrons courrent dans le circuit et donne le resultat. Sur le front descendant du signal carre, il gele les bits resultats du circuit, desactive le circuit, et deconnecte A et B aux entrees du circuit. Ensuite sur le front bas du signal carre, il copie le resultat du calcul dans le registre A. (il ne s'agit ici encore que d'ouverture de porte synchronise sur un signal)

A la fin de ce front bas, un cycle d'horloge a ete effectue, et une addition parallele un bit.

La partie commande aurait tres bien pu effectuer la meme demarche en selectionnant l'autre circuit pour effectuer un ADD2 A,B

Ou en es tu ?


FavernPosté le: 2002-03-15 16:29   
Bonjour,

Quote:

-254e+3 = -254 * 10^3 = -254 000
On a la mantisse qui est ici 245, et l'exposant qui est 3. Si l'exposant est negatif, on a des nombres a virgule.


Ce que je comprend pas c'est que si l'exposant est positif ou négatif dans tout les cas j'obtiens un nombre à virgule.
Car 254 x e(3)= 5101.73
Et 254 x e(-3)= 12.6459
???????????????????????????


"A la fin de ce front bas, un cycle d'horloge a ete effectue, et une addition parallele un bit."

Tu veux parler de quoi quand tu dis :"Addition parralele un bit" ? Il ne manque pas un mot ?


"La partie commande aurait tres bien pu effectuer la meme demarche en selectionnant l'autre circuit pour effectuer un ADD2 A,B"

Quel autre circuit ? De plus pourquoi faire un ADD1??? Puisque on à vue plus haut que un ADD2 utilise 2 bit. Donc si tu fais un ADD2 il vas te faire l'addition sur 2 bits. Donc ca sert à quoi de faire un ADD1 puis un ADD2


"Ou en es tu ?"

Bien je ne vois toujours pas ce que tu veux me faire voir


Tian> Ce schéma est bon ?


Favern


_________________
o----[:::::::::::::>®©

[ Ce message a été édité par: Favern le 2002-03-15 16:31 ]

TianPosté le: 2002-03-15 17:05   
Quote:

Le 2002-03-15 16:29, Favern a écrit:
Ce que je comprend pas c'est que si l'exposant est positif ou négatif dans tout les cas j'obtiens un nombre à virgule.
Car 254 x e(3)= 5101.73
Et 254 x e(-3)= 12.6459


Le calcul que tu as fais toi, c'est (254 * e^3) alors que la il s'agit de faire (254 * 10^3) je sais que cette notation est un peu ambigue. Mais cela n'a rien avoir avec e, tel que ln(e)=1
Quote:

Tu veux parler de quoi quand tu dis :"Addition parralele un bit" ? Il ne manque pas un mot ?


buzzz> Tu trouves pas qu'il chipote un peu? Au pire il manque en effet "a" entre "parralele" et "un"
Quote:

Quel autre circuit ? De plus pourquoi faire un ADD1??? Puisque on à vue plus haut que un ADD2 utilise 2 bit. Donc si tu fais un ADD2 il vas te faire l'addition sur 2 bits. Donc ca sert à quoi de faire un ADD1 puis un ADD2


Il s'agit du 2eme schema que tu as fait (qui donc est bon, a un detail pres, sans importance pour l'instant). Si la porte AND que tu as rajoute a un signal d'activation, on peut alors choisir en la desactivant de se retrouver dans le meme cas que ton 1er schema (2 fois addition en parallele de 1 bit sans lien entre les 2). En l'activant, on propage la retenue et on obtient une addition sur 2bits.

FavernPosté le: 2002-03-15 17:19   
Bonjour,

Non non: pour le mot je vous assure que je ne l'ai pas fait exprés. J'ai cherché pendant 2 minutes ce qu'il pouvait bien manquer. Mais je n'ai pas pensé à chercher avec des mots simple


Tian> Derniérement tu a dis ca:
"C'est pour cela que l'on parle de virgule flottante. Mais la valeur en memoire est quand meme toujours decoupee en champ de tailles fixes."

Je j'ai pas bien comprit je t'avoue.
Tu voulais dire quoi par "champ" ?

Donc si j'ai bien compris pour les virgules flottante, ca consiste juste à déplacer la virgule en utilisant des puissances de 10 afin d'avoir que des nombres entier ?

J'ai une question: Comment on fait si le nombre ne ce termine pas ? Comme 10/3 ?

Favern

buzzzPosté le: 2002-03-15 17:50   
Quote:

Mais la valeur en memoire est quand meme toujours decoupee en champ de tailles fixes.
Je j'ai pas bien comprit je t'avoue.
Tu voulais dire quoi par "champ" ?



Moi non plus , champs sinonyme de registre, enfin ici plutot un groupe de bits

Quote:

Donc si j'ai bien compris pour les virgules flottante, ca consiste juste à déplacer la virgule en utilisant des puissances de 10 afin d'avoir que des nombres entier ?



c'est effectivement le principe grosso modo

Quote:

J'ai une question: Comment on fait si le nombre ne ce termine pas ? Comme 10/3 ?



en fait on se debrouille pour coder le nombre sous la forme 0,xYYYYYYYY*10^K, x et Y etant des chiffres et x DOIT etre different de zero. Ainsi pour les nombres infinis il suffit de prendre le nombre 0,xxxxxxx qui s'approche le plus de la valeur de 10/3, donc electroniquement parlant le nombre sera ecrit : 0,33333333333.10^0
L'electronique fonctionne avec cette ecriture, il me semble que Tian te l'a explique a partir d'une mantisse entierer, c'est le meme principe de toute facon, mais avec l'ecriture de tian il n'y a pas de reponse a ta question. C'est aussi pour cela que l'autre possibilite 0,xxxxxx est choisie







_________________
perdu dans la thèse ou dans l'espace intergalactique... (depend des jours)

[ Ce message a été édité par: buzzz le 2002-03-15 17:51 ]

buzzzPosté le: 2002-03-15 18:02   
sinon pour les circuits tu as construit les DEUX BONS, felicitation

Tu as apparement compris le principe de fonctionnement : des registres physiquement fixe et des circuits de calculs differents. OK ?

Alors maintenant la seule chose au final qui te pose probleme est l'interet entre :
-faire une addition sur 2 bits
-faire deux additions de 1 bit

pourtant c'est completement different et c'est la qu'est tout l'interet.

Maintenant A et B sont des registres 32, (ca ne change rien au principe). Pour comprendre revenons a l'ancien exemple ou je voulais faire l'addition de deux vecteurs (x,y) (x',y'). J'ai deux choix :

-1 soit x,y,x',y' sont des entiers qui peuvent valoir de 0 a 4 millions, pour les representer, j'ai donc besoin de 32 bits pour CHACUN. Je n'ai donc pas le choix, je vais charger X et X' dans les registres A et B(cette fois de 32 bits) et faire l'addition, puis charger Y et Y' dans A et B et faire l'addition 32 bits

-2 doit x,y,x',y' sont des entiers qui peuvent valoi de 0 a 16000, pour les representer je n'ai besoin que de 16 bits pour chacun. Je charge donc X et Y dans A et X' Y' dans B, et j'utilise le premier schemas que tu as dessine ( 2 add de 1 bits, refait en 2 add de 16 bits). A au final cotiendra le resultat de deux additions 16 bits

interet, si tu peux coder tes valeurs sur 16 bits uniquement, tu fais 2 additions en parallele et tu gagnes 2 fois plus de temps.

L'analogie a faire est entre le circuit que tu as construit, qui fait soit 1 addition sur 2 bits ou 2 addition sur 1 bit et d'autres circuits qui font 1 addition sur 32 bits ou 2 additions sur 16.

Tu as tout les elements en main maintenant pour tout comprendre. J'ai fini le boulot... a toi de jouer

_________________
perdu dans la thèse ou dans l'espace intergalactique... (depend des jours)

[ Ce message a été édité par: buzzz le 2002-03-15 18:02 ]

[ Ce message a été édité par: buzzz le 2002-03-15 18:04 ]

FavernPosté le: 2002-03-15 18:25   
Quote:

Le 2002-03-15 17:50, buzzz a écrit:
en fait on se debrouille pour coder le nombre sous la forme 0,xYYYYYYYY*10^K, x et Y etant des chiffres et x DOIT etre different de zero. Ainsi pour les nombres infinis il suffit de prendre le nombre 0,xxxxxxx qui s'approche le plus de la valeur de 10/3, donc electroniquement parlant le nombre sera ecrit : 0,33333333333.10^0
L'electronique fonctionne avec cette ecriture, il me semble que Tian te l'a explique a partir d'une mantisse entierer, c'est le meme principe de toute facon, mais avec l'ecriture de tian il n'y a pas de reponse a ta question. C'est aussi pour cela que l'autre possibilite 0,xxxxxx est choisie


Si je te suis bien buzzz, l'autre méthode décriture serait de décaler la virgule dans l'autre sens afin d'avoir un nombre du genre 0,xxxxxxxxxxxxx.10^n ??

Mais je croyais qu'il fallait absolument retirer la virgule ? Donc ca donnerais plutot 33333333333.10^n non ?

Quote:

Tu as apparement compris le principe de fonctionnement : des registres physiquement fixe et des circuits de calculs differents. OK ?


Euhh non: Les registres ne sont pas fixe. On à vue que avec un LOAD on peux modifier la largeur ?

En toute franchise dans ton exemple j'arrive pas du tout à comprendre comment les schémas peuvent m'aider ?

Mais je viens de comprendre je pense:
Voici comment je vois ca:
Si j'ai des nombre donné:
X (0000000000001001)
X'(0000000000100100)
Y (0000000001010100)
Y'(0000010100101000)

Donc on colle ensemble X et Y
Et on obtient ca:
00000000000010010000000001010100

Puis on colle X' et Y'
00000000001001000000010100101000

Et on fait l'addition des 2:
Code:

00000000000010010000000001010100
+00000000001001000000010100101000
=00000000001011010000010101111100


Puis on redécompose le nombre en 2 mots de 16 bits Et ainsi j'obtient le résultat:
X+X'=0000000000101101
Et de
Y+Y'=0000010101111100

Donc est ce que j'ai bon ?


"L'analogie a faire est entre le circuit que tu as construit, qui fait soit 1 addition sur 2 bits ou 2 addition sur 1 bit et d'autres circuits qui font 1 addition sur 32 bits ou 2 additions sur 16."

Je ne comprend pas. Car mes circuit font bien 2 additions sur 2 bits ?

Favern

buzzzPosté le: 2002-03-15 19:00   
youpie yaouuuuuuuu

oui tu as tout compris !!!

ouf merci

non
celui avec 3 bascules fait une addition sur 2 bits

le premier schemas donne fait deux additions d'un bit

la difference vient quand tu fais 01(3)+01(1)
dans un cas tu obtiens 10 (4) et dans l'autre 00, il faut voir ici que la retenue n'a pas ete prise en compte. Quant a l'addition qui a donne 0 (1+1) elle est fausse car le bon resultat etait 10, mais comme on travaille sur un bit, le resultat est coupe donc on gar le 0 du 10

rappel

addition 2 bits :

01
+01
----
10

2additions 1bit parallele

0 1+
0 1
----
0 0

FavernPosté le: 2002-03-16 07:09   
Quote:

Le 2002-03-15 19:00, buzzz a écrit:
non
celui avec 3 bascules fait une addition sur 2 bits


Des bascules ?
Où est ce que j'ai fais des bascules ? J'ai juste monté des portes logique ?

Quote:

la difference vient quand tu fais 01(3)+01(1)
dans un cas tu obtiens 10 (4) et dans l'autre 00, il faut voir ici que la retenue n'a pas ete prise en compte. Quant a l'addition qui a donne 0 (1+1) elle est fausse car le bon resultat etait 10, mais comme on travaille sur un bit, le resultat est coupe donc on gar le 0 du 10


Je ne comprend pas là ?
01 ca fait 1 et non 3 ?
De plus comment veux tu obtenir 4 avec 2 bits ?
Quote:

addition 2 bits :

01
+01
----
10

2additions 1bit parallele

0 1+
0 1
----
0 0



Oui bien sur. Je suis d'accord.
Mais tu veux me faire voir quoi avec tout ca ? J'arrive toujours pas à voir où tu veux m'emmener ?

Favern

buzzzPosté le: 2002-03-16 13:33   
la difference vient quand tu fais 01(1)+01(1)
dans un cas tu obtiens 10 (2) et dans l'autre 00, il faut voir ici que la retenue n'a pas ete prise en compte. Quant a l'addition qui a donne 0 (1+1) elle est fausse car le bon resultat etait 10, mais comme on travaille sur un bit, le resultat est coupe donc on gar le 0 du 10

---- fatigue, excusez ----

ou je veux t'emmener ? simplement a remarquer que quand on fait des additions paralleles sur un registre 256 ou autres, on ne change pas de registre, mais de circuit pour effectuer la manip






FavernPosté le: 2002-03-16 14:29   
Quote:

Le 2002-03-16 13:33, buzzz a écrit:
la difference vient quand tu fais 01(1)+01(1)
dans un cas tu obtiens 10 (2) et dans l'autre 00, il faut voir ici que la retenue n'a pas ete prise en compte. Quant a l'addition qui a donne 0 (1+1) elle est fausse car le bon resultat etait 10, mais comme on travaille sur un bit, le resultat est coupe donc on gar le 0 du 10



Oui. Je suis entiérement d'accord.

Quote:

ou je veux t'emmener ? simplement a remarquer que quand on fait des additions paralleles sur un registre 256 ou autres, on ne change pas de registre, mais de circuit pour effectuer la manip


Change de circuit ? Comment ca ?
On à pourtant vue que l'on mettait les 2 mot de 16 bits l'un à coté de l'autre.

Si on reprend l'exemple sur lequel je m'était défoulé, c'est à quel moment que l'on change de circuit ? Et pourquoi ?
Quote:

Si j'ai des nombre donné:
X (0000000000001001)
X'(0000000000100100)
Y (0000000001010100)
Y'(0000010100101000)

Donc on colle ensemble X et Y
Et on obtient ca:
00000000000010010000000001010100

Puis on colle X' et Y'
00000000001001000000010100101000

Et on fait l'addition des 2:
Code:

00000000000010010000000001010100
+00000000001001000000010100101000
=00000000001011010000010101111100


Puis on redécompose le nombre en 2 mots de 16 bits Et ainsi j'obtient le résultat:
X+X'=0000000000101101
Et de
Y+Y'=0000010101111100



Favern

buzzzPosté le: 2002-03-16 16:44   
[quote]
Et on fait l'addition des 2:
[\quote]
c'est a ce moment la qu'on bascule soit sur le circuit ADD // ou ADD normale (le circuit avec les portes logiques)

En fait, la il y a encore un trou dans ta comprehension, l'action "coller" n'existe pas.

En effet, quand tu lis un nombre 32 bits de la memoire dans un registre 32. Tu fais
MOV Reg32,[adresse] a l'adresse tu as :
X: 00000001000000010000000100000001
et apres dans le Reg32 tu auras la valeur
00000001000000010000000100000001

Si tu bosses en 16 bits.. effectivement si tu as X a l'adresse adr1 et X' a l'adresse adr2 il faudrait faire 2 MOV sur chaque partie du registre. Ceci n'est pas utilise, car si l'architecture est 32 bits, lire deux mots de 16bits a des adresses differentes fait perdre 50% d'efficacite, car lire 2 fosi 16bits non contigus est aussi chere que de lire 2 fois 32 bits a deux endroits differents. Donc aucun interet

On prefera mettre en memoire X et X' l'un apres l'autre cad, a l'adresse adr1 pour X et adr1+2octects pour X', ainsi tu lis les deux d'un seul coup car 32 bits contigues ca passe direct dans le bus en un cycle.
et on ecrira :
MOV16 Reg32,[adr1]
et ca fera dans ce cas precis de configuration des donnees :

X (0000000000001001)
X'(0000000000100100)

Reg 32 : 00000000000010010000000001010100

? oui non

FavernPosté le: 2002-03-16 17:09   
Bonjour Buzzz,

Bon je vois ce que tu veux dire.

On perd 50% d'efficacité si on prend, le premier mot de 16bits et qu'on le met dans le registre, puis qu'aprés on met le deuxiéme mot de 16 bits dans le registre.
Effectivement il faut faire ca en 2 temps.

Quote:

On prefera mettre en memoire X et X' l'un apres l'autre cad, a l'adresse adr1 pour X et adr1+2octects pour X', ainsi tu lis les deux d'un seul coup car 32 bits contigues ca passe direct dans le bus en un cycle.
et on ecrira :
MOV16 Reg32,[adr1]
et ca fera dans ce cas precis de configuration des donnees :
X (0000000000001001)
X'(0000000000100100)
Reg 32 : 00000000000010010000000001010100
? oui non


Presque

Reprenons notre exemple.
Si je te suis bien voici ce que ca donnerais:

J'ai toujours 2 nombres:
X (0000000000001001) Adresse [1001]
X'(0000000000100100) Adresse [1002]

Donc je prend X et je le déplace à l'adresse [1004].
Ensuite je balance X' dans un registre afin de lui faire ajouter 1 octet.
Ce qui me donnera X'' (0000000001010100)
Une fois le calcul effectué, je prend X'' et je le met avant X à l'adresse [1004].

Et donc là je me retrouve avec mon mot de 32bits composé de X + X' + 1 octet.

C'est bien ca ?


Si oui je t'avoue avoir du mal à voir où est le gain car ils faut faire encore plus d'opération comparé à la 1ére méthode ?

De plus pourquoi rajoutes tu 1 octet ?

Favern

buzzzPosté le: 2002-03-16 22:37   
houla, tu m'as fait une grosse soupe la

Reprenons l'exemple.
J'ai X,X',Y,Y' 4 nombre entiers de 16 bits, et je veux calculer X+X' et Y+Y' en parallele en un cyle, cad effectuer 2 additions en 1 coup

jusque la normalement c'est ok

ensuite c'est la soupe
quand on donne une adresse, c'est une adresse en octect en memoire. OR X,Y,X'... sont des valeurs qui prennent 16 bits donc DEUX octects de large. Nous allons donc les disposer de la maniere suivante :
X a l'adresse 1000
Y a l'adresse 1002
X' a l'adresse 1004
Y' a l'adresse 1006

Ils sont stockes en memoire ainsi et de maniere permanente. On ne les promene pas d'une case memoire a l'autre.

En effuctant MOV16 A,[1000]
A va contenir X et Y en 1 seul coup.
puis MOV16 B,[1004]
B va contenir X' et Y' en 1 seul cycle.
ensuite
ADD16 A,B
La 2 additions paralleles sur 16bits.
A contient : X+X' | Y+Y'
et on finit par
MOV16 [1000],A
ainsi apres on aura en memoire

X+X' a l'adresse 1000
Y+Y' a l'adresse 1002
X' a l'adresse 1004
Y' a l'adresse 1006


en stockant tous nombres en 32 bits on aurait 2 fois plus de temps. S'ils peuvent rentrer dans 16 et que l'on peut effectuer 2 additions paralleles en 16, c'est tout bon.

Bon sinon je dois avouer mettre planter quelque part. Cette syntaxe que j'ai utilise pour MOV16 n'a pas dans le monde langage machine de sens. Et si elle en avait un ce serait plutot le chargement d'une seule valeur de 16 bits et non le chargement de deux valeurs 16 bist en bloc. Car en effet quand je fais

MOV16 A,[1000]
je charge dans les 4 octets du registre A, les octets contenus aux adresse 1000,1001,1002,1003
et je fais exactement la meme chose avec
MOV32 A,[1000]

la seule difference etait que dans le premier cas, je deplacais 2 nombres de deux octets et dans le deuxieme 1 nombre de 4 octets. Physiquement j'ai mis les 4 meme octects sur le bus et ils ont finis au meme endroit (dans A).



_________________
perdu dans la thèse ou dans l'espace intergalactique... (depend des jours)

[ Ce message a été édité par: buzzz le 2002-03-16 22:39 ]

FavernPosté le: 2002-03-17 08:34   
Bonjour,

Quote:

Le 2002-03-16 22:37, buzzz a écrit:
houla, tu m'as fait une grosse soupe la
En effuctant MOV16 A,[1000]
A va contenir X et Y en 1 seul coup.


Comment en appelant simplement 1 adresse tu peux faire venir 2 mots de 2 adresses différentes ?

Quote:

ensuite
ADD16 A,B
La 2 additions paralleles sur 16bits.
A contient : X+X' | Y+Y'


Mais tu travailles alors avec un registre de 128bits ?

Quote:

et on finit par
MOV16 [1000],A
ainsi apres on aura en memoire
X+X' a l'adresse 1000
Y+Y' a l'adresse 1002


Je ne comprend pas comment en exécuant simplement une commande comprenant 1 adresse tu peux dire à 2 mots d'aller sur une seconde adresse.
Je comprend que le premier aille sur l'adresse 1000 car c'est dans la commande. Mais pourquoi le second à été à l'adresse 1002 ??????????

Quote:

Bon sinon je dois avouer mettre planter quelque part. Cette syntaxe que j'ai utilise pour MOV16 n'a pas dans le monde langage machine de sens. Et si elle en avait un ce serait plutot le chargement d'une seule valeur de 16 bits et non le chargement de deux valeurs 16 bist en bloc. Car en effet quand je fais
MOV16 A,[1000]
je charge dans les 4 octets du registre A, les octets contenus aux adresse 1000,1001,1002,1003
et je fais exactement la meme chose avec
MOV32 A,[1000]
la seule difference etait que dans le premier cas, je deplacais 2 nombres de deux octets et dans le deuxieme 1 nombre de 4 octets. Physiquement j'ai mis les 4 meme octects sur le bus et ils ont finis au meme endroit (dans A).


Tu m'as perdu là je crois.
C'est quoi alors qui ne correspond plus ?

Favern

_________________
o----[:::::::::::::>®©

[ Ce message a été édité par: Favern le 2002-03-17 08:35 ]

nicholas_fr2001Posté le: 2002-03-17 17:04   
Bonjour,

Ce week end, j'ai essayé de comprendre tout ce qui se disait sur les GPU et j'y ai passé 4 heures non stop car ça m'interresse trop mais en semaine pas trop le temps.
et J'ai galéré pour essayer de comprendre tout ça d'un coup et autant vous dire que je n'ai pas que 2 neuronnes qui ont sauté comme Favern mais tous
Heuresement que je commence à comprendre tout se qu'il s'est dit.
Sinon après 4heures passés ce serait grave.

Mais il faut que je comprenne tout ça et je vais y arriver ( enfin j'espère )

Favern, je suis avec toi et merci de faire avancer ce sujet.

Courage on va y arriver

Nicolas

nicholas_fr2001Posté le: 2002-03-17 17:13   
Merci aussi a Buzzz pour sa patience et toutes ces explications
buzzzPosté le: 2002-03-17 23:54   
ca me fait plaisir toute cette motivation.
4 heures pour comprendre tout cela, c'est pas si mal au final Cela fait quand meme beaucoup d'info

Bon alors pour repondre a favern.
quand j'ecris [1000] cela designe la valeur contenue a PARTIR de la case memoire numero 1000. Neanmoins on ne connait pas la taille de l'information stockee, si c'est un entier 32 bits, il sera sur les cases 1000,1001,1002,1003 et en ecrivant [1000] pour ce nombre 32 bits, je designerai les 4 cases. Pour un nombre 16 bits, [1000] designera que les cases 1000 et 1001.

Comment le proc s'y retouve ?


Suivant l'architecture de la machine, plusieurs octects peuvent etre lus et transferes en meme temps. Cela depend surtout de la largeur du bus fourni par le carte mere, ie bus au sens nombre de fils pour transferer les bits . Sur les machines actuelles, PIII duron/athlon, la largeur de bus est de 32 bits, 4 octects. Donc par cycle 4 octects peuvent etre mis sur le bus a la fois. La machine pour faire cela demande quand meme 2 conditions :
- que les 4 octects soient consecutif en memoire
- que le premier commence a une adresse qui soit un multiple de 4

Alors comment le proc s'y retrouve, pour les registres intel c'est simple, c'est le nom du registre a charger qui donne la quantite a transferer.
Ainsi : MOV AX,[1000]
Ax est un regsitre 16 bits, on va donc se servir des deux octects au adresse 1000 et 1001 pour le remplir

MOV EAX,[1000]
EAX est un registre 32 bits, on va donc se servire des 4 octects places a l'adresse 1000,1001,1002,1003 pour le remplir

Pour une architecture 32 bits, faire MOV EAX ou un MOV AX prend dans tous les cas 1 cycle.
EAX est parfois renomme simplement AX pra abus de langage car les programmeurs n'utilisent plus AX, et toujours EAX par defaut, donc ils ont tendance a continuer a dire AX bien qu'il parle de EAX.

Pour les registres MMX, registres du GPU c'est un poil different, le principe reste le meme. Comme on recherche l'efficacite, quand il y a un chargement de registre a faire on charge le maximum. La question est donc de savoir qu'est ce qu'on charge. Pour un registre MMX 64 bits

La question est de savoir si on charge 1 entier de 64 bits, 2 de 32, 4 de 16 ou 8 de 8, l'instruction est la meme, MOVQ

Dans tous les cas on va charger en memoire 8 octects contigus. MOVQ MM0,[1000] :

Pour 8 valeurs de 8 bits chacune
1000 : valeur 1 = 00001110
1001 : valeur 2 = 00001100
1002 : valeur 3 = 00001000
1003 : valeur 4 = 00001000
1004 : valeur 5 = 00001010
1005 : valeur 6 = 00001011
1006 : valeur 7 = 00000011
1007 : valeur 8 = 00011111
Ainsi j'ecrirais MOVQ MM0,[1000]
et j'aurais
MM0 = 00001110 00001100 00001000 00001000 00001010 00001011 00000011 00011111

Si je veux charger 2 valeurs de 32 bits
adresse 1000 : 100000111000011100000000000000111
adresse 1004 :
101000101000011010101111010100111

en ecrivant MOVQ MM0,[1000]

et j'aurais
MM0 = 100000111000011100000000000000111
101000101000011010101111010100111

[q]Au final on transfere toujours les octects aux adresses 1000,1001,...,1007 au position 1,2,3,4,5,6,7,8 dans le registre MM0, que l'on lise 8 nombres de 8bits ou 2 de 32[/b]

Apres quand on effectue les calculs on differenciera les instructions suivant que ce que l'on veut faire

ADD8 MM0,? effectuera 8 additions 8 bits en paralleles (cas un de cet exemple)

ADD32 MM0,? effectuere 2 additions 32 bits en parallele.

bon ou en etes vous.
faites confiance a cette version, j'ai mis un certain effort a la rediger.






_________________
perdu dans la thèse ou dans l'espace intergalactique... (depend des jours)


[ Ce message a été édité par: buzzz le 2002-03-18 00:27 ]

[ Ce message a été édité par: buzzz le 2002-03-18 00:31 ]

FavernPosté le: 2002-03-19 19:43   
Bonjour buzzz,

Excues ma réponse tardive mais j'ai eu un peu de boulot là

Mais franchement buzzz, pourquoi tu est parties dans le MMX ? Déja que j'ai du mal à suivre le AX ?


Je vais reprendre mon exemple en m'aidant de ce que tu m'as dit dans le début du message.

Si je te suis bien voici ce que ca donnerais:

Il faut retenir que AX est un registre de 32 bit.
J'ai toujours 2 nombres:
X (0000000000001001) Adresse [1001]
X'(0000000000100100) Adresse [1002]

Donc j'envoie la commande:
"MOV16 AX,[1001]" ou "MOV32 AX,[1001]" (J'ai pas comprit la différence entre les 2 ?)
Donc là il vas voir que AX est un registre de 32bits et qu'a l'adresse 1001 il y a un nombre de 16bits. Donc il vas aller voir à coté pour essayer de remplir.
Donc là il vas me copier le contenue de l'adresse 1001 et le cotenue de l'adresse 1002 vers le registre AX.
Donc on vas obtenir X+X':
00000000000010010000000000100100

Et maintenant que ce mot est dans le registre je dois donc lui rajouter 1 octet.
Donc je lui fais faire une simple addition. Ce qui me donnera en final:
00000000000010010000000001010100

Et là je le renvoie vers une adresse pour étre stocké afin que je puisse faire la méme chose avec Y et Y' ?


Donc est ce que j'ai bon maintenant ?

Favern

BuggyBoyPosté le: 2002-03-19 20:24   
Coucou,

juste une petite interruption, parce que je suis en train de lire ce topic avec un PAL8045 sur la tête et un thermomètre dans la bouche.

Est il nécessaire d'ajouter de la pâte thermique?

FavernPosté le: 2002-03-19 20:38   
Bonjour BuggyBoy,

Je te demanderais de bien vouloir ouvrir un nouveau topic pour poser ta question.

Merci d'avance

Favern

BuggyBoyPosté le: 2002-03-19 20:45   
Désolé.
nicholas_fr2001Posté le: 2002-03-19 21:22   
Quote:

Le 2002-03-19 19:43, Favern a écrit:
Bonjour buzzz,

Il faut retenir que AX est un registre de 32 bit.
J'ai toujours 2 nombres:
X (0000000000001001) Adresse [1001]
X'(0000000000100100) Adresse [1002]

Donc j'envoie la commande:
"MOV16 AX,[1001]" ou "MOV32 AX,[1001]" (J'ai pas comprit la différence entre les 2 ?)
Donc là il vas voir que AX est un registre de 32bits et qu'a l'adresse 1001 il y a un nombre de 16bits. Donc il vas aller voir à coté pour essayer de remplir.
Donc là il vas me copier le contenue de l'adresse 1001 et le cotenue de l'adresse 1002 vers le registre AX.
Donc on vas obtenir X+X':
00000000000010010000000000100100

Et maintenant que ce mot est dans le registre je dois donc lui rajouter 1 octet.
Donc je lui fais faire une simple addition. Ce qui me donnera en final:
00000000000010010000000001010100

Et là je le renvoie vers une adresse pour étre stocké afin que je puisse faire la méme chose avec Y et Y' ?


Donc est ce que j'ai bon maintenant ?

Favern




Bonjour,

Je serai d'accord pour confirmer ce que tu nous dit là Favern car j'aurai fait la même chose. Mais attendons confirmation.

Buzz> est-ce que tu n'aurait pas des exos pour pouvoir mettre en oeuvre tout ça?

Pour pouvoir bien comprendre, il faut que j'applique sinon, je vais vite oublier.
Car meme si j'arrive un peu à comprendre, c quand même un peu brouillon car tout se mélange

Merci

a+

Nicolas

buzzzPosté le: 2002-03-19 21:34   
La correction
Quote:

Il faut retenir que AX est un registre de 32 bit.


ok faisons comme cela

Quote:

J'ai toujours 2 nombres:
X (0000000000001001) Adresse [1001]
X'(0000000000100100) Adresse [1002]


ok mais faux, faut lire un peu ce que j'ecris, ces deux nombres sont de 16bits, donc ils prennent deux octects pour etre stockees. Si X est a l'adresse 1001, X' ne peut etre qu'a l'adresse 1003.

Quote:

Donc j'envoie la commande:
"MOV16 AX,[1001]" ou "MOV32 AX,[1001]" (J'ai pas comprit la différence entre les 2 ?)
Donc là il vas voir que AX est un registre de 32bits et qu'a l'adresse 1001 il y a un nombre de 16bits. Donc il vas aller voir à coté pour essayer de remplir.
Donc là il vas me copier le contenue de l'adresse 1001 et le cotenue de l'adresse 1002 vers le registre AX.



MOV16 AX = MOV32 AX, ils sont equivalents
sinon c'est ok en remplacant 1002 par 1003 (voir remarque ci-dessus).


Quote:

Donc on vas obtenir X+X':
00000000000010010000000000100100


+ au sens de la concatenation (ecriture juxtaposee)

Quote:

Et maintenant que ce mot est dans le registre je dois donc lui rajouter 1 octet.
Donc je lui fais faire une simple addition. Ce qui me donnera en final:
00000000000010010000000001010100



non perdu, on ne fait pas des additions entre les morceux d'un registre, du moins en // non. Cela est immaginagle mais neanmoins ce n'est pas implante comme cela.



Quote:

Et là je le renvoie vers une adresse pour étre stocké


yes

Quote:

afin que je puisse faire la méme chose avec Y et Y' ?



non
il te faut 2 registres minimums
On prend AX 32 bits et BX 32 bits

on met X a l'adresse 1001 Y a 1003
X' a 1005 et Y' a 1007
ensuite :

MOV AX,1001 ( AX = X | Y)
MOV BX,1005 ( BX = X' | Y')
ADD16 AX,BX
MOV ???,AX

exemple :
X = 0000000000000001 Y = 1000000000000011
X'= 0110000000111000 Y'= 0000011110000000

avec
MOV AX,1001 ( AX = X | Y)
MOV BX,1005 ( BX = X' | Y')
j'obtiens :

AX = 00000000000000011000000000000011
BX = 01100000001110000000011110000000

puis ADD16 AX,BX

AX = 01100000001110011000011110000011

soit X+X' | Y+Y'

a bientot


_________________
perdu dans la thèse ou dans l'espace intergalactique... (depend des jours)


[ Ce message a été édité par: buzzz le 2002-03-19 21:39 ]

nicholas_fr2001Posté le: 2002-03-19 22:00   
evidement avec la correction ça va tout seul.
FavernPosté le: 2002-03-20 07:38   
Bonjour Buzzz,

Quote:

ok mais faux, faut lire un peu ce que j'ecris, ces deux nombres sont de 16bits, donc ils prennent deux octects pour etre stockees. Si X est a l'adresse 1001, X' ne peut etre qu'a l'adresse 1003.


Non non, je t'assure que je lis tout. Mais je croyais que ce systéme de gestion de la mémoire été spécialisé dans le MMX ?

Donc on trouve uniquement des mémoires contenant 1 octet ?

Quote:

on met X a l'adresse 1001 Y a 1003
X' a 1005 et Y' a 1007
ensuite :
MOV AX,1001 ( AX = X | Y)
MOV BX,1005 ( BX = X' | Y')
ADD16 AX,BX
MOV ???,AX
exemple :
X = 0000000000000001 Y = 1000000000000011
X'= 0110000000111000 Y'= 0000011110000000
avec
MOV AX,1001 ( AX = X | Y)
MOV BX,1005 ( BX = X' | Y')
j'obtiens :
AX = 00000000000000011000000000000011
BX = 01100000001110000000011110000000
puis ADD16 AX,BX
AX = 01100000001110011000011110000011
soit X+X' | Y+Y'


OK Pour toute cette partie là, c'est trés clair. Merci


Mais il y a quelques temps tu avais dit cela:
Quote:

On prefera mettre en memoire X et X' l'un apres l'autre cad, a l'adresse adr1 pour X et adr1+2octects pour X', ainsi tu lis les deux d'un seul coup car 32 bits contigues ca passe direct dans le bus en un cycle.


Donc c'est quand que on rajoute un octet ?
De plus cet octet viendrais d'où ?

Favern

_________________
o----[:::::::::::::>®©

[ Ce message a été édité par: Favern le 2002-03-20 07:40 ]

buzzzPosté le: 2002-03-20 09:00   
Quote:

On prefera mettre en memoire X et X' l'un apres l'autre cad, a l'adresse adr1 pour X et adr1+2octects pour X', ainsi tu lis les deux d'un seul coup car 32 bits contigues ca passe direct dans le bus en un cycle.


Donc c'est quand que on rajoute un octet ?
De plus cet octet viendrais d'où ?



je ne vois pas la contradiction. Tous les systemes de memoire PC comptent en bloc d'un octect. Si X est a 1001 est fait 16 bits de large X' comme dans l'exemple ne peut se trouver qu'a 1003 (=adr1+2octets).


Quand est-ce qu'on rajoute un octet ??? je sais pas, c'est toi qui a sorti ca un jour, je ne sais pourquoi ni comment tu as pu pense cela ??? je ne vois pas ou j'ai dit un truc dans le genre, on a du se louper...

a+

FavernPosté le: 2002-03-21 10:51   
Bonjour Buzzz,
Quote:

Le 2002-03-20 09:00, buzzz a écrit:
Quand est-ce qu'on rajoute un octet ??? je sais pas, c'est toi qui a sorti ca un jour, je ne sais pourquoi ni comment tu as pu pense cela ??? je ne vois pas ou j'ai dit un truc dans le genre, on a du se louper...
a+


Et bien ici:
http://www.forumschoixpc.com/viewtopic.php?topic=10668&forum=11&post_flagged=83060&start=60

"On prefera mettre en memoire X et X' l'un apres l'autre cad, a l'adresse adr1 pour X et adr1+2octects pour X', ainsi tu lis les deux d'un seul coup car 32 bits contigues ca passe direct dans le bus en un cycle. "

Que représente ces 2 octets supplémentaire que l'on rajoute à X' ?

Favern

_________________
o----[:::::::::::::>®©

[ Ce message a été édité par: Favern le 2002-03-21 10:52 ]

buzzzPosté le: 2002-03-21 20:01   
un octect non

2 octect oui j'en ai effectivement parle. Et encore dans l'exemple ci dessus.

Si une valeur X de 16 bits de large commence a l'adresse 1001, elle occupera 1001 et 1002 car elle fait 2 octects de large. Donc si une autre valeur X' de 16 bits est stockee en memoire ce sera au mieux a partir de la premiere case libre : 1003 et elle occupera 1003 et 1004. Bon alors

"adr1 + 2 octects pour X'" il fallait lire (je viens de comprenre ce que tu avais compris) :
adr1 + 2octects (1001 + 2 = 1003) est l'adresse de X'

voila.

FavernPosté le: 2002-03-24 07:36   
Bonjour,

A d'accord merci beaucoup.

Je pense avoir comprit la mal de chose là déja. Un grand merci Buzzz et Tian

Favern