FR 2804523 A1 20010803 FR 0012031 A 20000921 La présente invention concerne les systèmes informatiques numériques, et plus particulièrement, mais sans y être limitée, des procédés et un dispositif pour mettre en oeuvre deux architectures ou plus sur une puce. II existe des microprocesseurs qui mettent en oeuvre une architecture de jeu d'instructions (ISA) pour ordinateurs à jeu d'instructions réduit (RISC) et une ISA indépendante pour ordinateurs à jeu d'instructions complexes (CISC) en émulant les instructions CISC par des instructions natives au jeu d'instructions RISC. Les instructions de I'ISA CISC sont appelées "macro- instructions". Les instructions de l'ISA RISC sont appelées "micro- instructions". Les microprocesseurs existants ne mettent pas ces deux architectures en oeuvre aussi efficacement que possible. Certains processeurs existants utilisent des fils plus globaux qui acheminent des données vers de nombreuses parties de la puce. Ceci rend l'acheminement de la puce plus difficile et moins efficace. Ces techniques compliquent aussi la synchronisation et le pipeline du processeur. II est souhaitable de créer des moyens efficaces pour mettre en oeuvre les deux architectures sur une puce unique, tout en supportant le matériel existant. En particulier, il est souhaitable de localiser le traitement et la distribution des instructions, avec un impact minimal sur le moteur d'exécution existant. La présente invention est un procédé pour mettre en oeuvre deux architectures sur une puce unique. Le procédé utilise un moteur d'extraction pour rappeler des instructions. Si les instructions sont des macro-instructions, alors il décode les macro-instructions en micro-instructions, et assemble ensuite ces micro-instructions en paquets à l'aide d'un dispositif d'assemblage en paquets, à l'intérieur d'un moteur d'émulation. Les paquets sont émis en parallèle et distribués au moteur d'exécution et contiennent des bits de décodage préliminaire de sorte que le moteur d'exécution les traite comme des micro-instructions. Avant d'être transférées au moteur d'exécution, les instructions peuvent être contenues dans un tampon. Le procédé sélectionne également entre micro-instructions assemblées en paquet provenant du moteur d'émulation et micro-instructions natives provenant directement du moteur d'extraction, à l'aide d'un multiplexeur ou d'autres moyens. Aussi bien les micro-instructions natives que les micro-instructions assemblées en paquet peuvent être contenues dans le tampon. Le procédé envoie également des informations supplémentaires au moteur d'exécution. La présente invention est également un système informatique ayant un processeur capable de mettre en oeuvre deux architectures. Le système informatique dispose d'un moteur d'extraction pour rappeler des instructions, d'un moteur d'exécution pour exécuter les instructions et d'un moteur d'émulation pour décoder les macro-instructions en micro-instructions avant leur exécution. Le moteur d'émulation utilise un dispositif d'assemblage en paquets pour assembler les micro-instructions et d'autres informations en groupes. Ces paquets sont fournis en parallèle au moteur d'exécution. - La Figure 1 est un schéma fonctionnel d'un microprocesseur RISC ; - la Figure 2 est un schéma fonctionnel d'un microprocesseur RISC mon trant des détails supplémentaires du traitement des instructions RISC et CISC ; - la Figure 3 est un schéma fonctionnel d'un moteur d'émulation ; - la Figure 4 est un schéma fonctionnel montrant le format de paquet ; - la Figure 5 est un organigramme montrant le fonctionnement du dispo sitif d'assemblage en paquets. MICROPROCESSEUR RISC Dans un sens très simpliste, un microprocesseur RISC peut être divisé en deux parties : un moteur d'extraction d'instruction et un moteur d'exécution. La Figure 1 montre un schéma fonctionnel d'un microprocesseur RISC 10, disposant d'un moteur d'extraction 20 et d'un moteur d'exécution 40. Dans certaines mises en oeuvres, telles que la mise en oeuvre montrée sur la Figure 1, le moteur d'extraction est séparé du moteur d'exécution par un tampon 30. Ce tampon 30, également appelé file d'attente, peut être utilisé pour découpler le moteur d'extraction 20 du moteur d'exécution 40. Pendant que le moteur d'extraction 20 écrit une nouvelle instruction entrante dans le tampon 30, le moteur d'exécution 40 lit et retire des instructions du tampon 30 dans le même ordre que celui de leur écriture. Tant qu'il reste de la place dans le tampon 30, le moteur d'extraction 20 peut prendre de l'avance sur le moteur d'exécution 40. Dès que le tampon 30 se remplit, le moteur d'extrac- tion 20 doit s'arrêter et attendre que le moteur d'exécution 40 prenne une instruction et libère une zone d'entrée dans le tampon 30. Toutefois, si le tampon 30 est vide, il est possible de créer un chemin de contournement 50 autour du tampon 30 de sorte que des instructions nouvellement extraites puissent passer du moteur d'extraction 20 directement au moteur d'exécution 40 sans être d'abord écrites dans le tampon 30. La présente invention émule une ISA CISC sur une machine RISC. La Figure 2 montre un schéma fonctionnel d'un microprocesseur RISC 10 après mise en oeuvre de la présente invention. Pour mettre en oeuvre fa présente invention, un moteur d'émulation 60 est nécessaire pour convertir un flux d'octets d'instruction en une séquence de micro-instructions qui peut être comprise par le moteur d'exécution RISC 40. Comme le montre la Figure 2, le moteur d'émulation 60 reçoit un flux d'instructions provenant du moteur d'extraction 20 et fournit les micro-instructions au moteur d'exécution 40. Dans un mode de réalisation préféré, la présente invention utilise un multiplexeur 70 pour sélectionner des instructions provenant soit du moteur d'extraction 20 soit du moteur d'émulation 60. Le multiplexeur 70 place alors les instructions sélectionnées dans le tampon d'instructions 30. Le moteur d'émulation 60 n'a pas de chemin de contournement 50 autour du tampon d'instructions 30 parce que l'ajout d'un chemin de contournement 50 amènerait la machine à fonctionner à une fréquence inférieure même pendant l'exécution en mode natif (RISC). Pendant l'exécution en mode natif, le moteur d'extraction 20 fournit 32 octets de flux d'instructions au moteur d'exécution 40. Dans tous les 16 octets, ou "paquet", FISA RISC définit qu'il y a trois instructions sur 41 bits et cinq bits d'informations de modèle. De plus, le moteur d'extraction 20 envoie d'autres informations de commande, appelées bits de décodage préliminaire, qu'il décode à partir des 16 octets du flux d'instructions. Les bits de décodage préliminaire sont utilisés par le moteur d'exécution 40 pour l'aider à distribuer efficacement les six instructions aux unités d'exécution adéquates. Pendant l'exécution en mode émulation, le moteur d'exécution 40 doit recevoir des données exactement dans le même format qu'en mode natif. Ceci permet à la plus grande partie du moteur d'exécution 40 d'être conçue uniquement pour l'exécution en mode natif, tout en lui permettant d'être également utilisée en mode émulation. Ainsi, le moteur d'émulation 60 doit également fournir 32 octets de données d'instruction en même temps que les bits de décodage préliminaire calculés à partir de ces 32 octets. Comme exposé ci-dessus, il existe six instructions de mode natif contenues dans les 32 octets du flux d'instructions. Cependant, les besoins en performances de cette machine sont tels qu'en mode émulation, il suffit de fournir un maximum de deux instructions de mode natif par cycle au moteur d'exécution 40. Ceci simplifie la conception du matériel d'émulation en raison des codages de modèle et des besoins de dépendance entre instructions qui sont imposés par l'ISA RISC. En plaçant uniquement une instruction et deux NOP ensemble par paquet, le matériel d'émulation a une tâche nettement plus facile en respectant ces besoins architecturaux. DISPOSITIF D'ASSEMBLAGE EN PAQUETS Comme indiqué ci-dessus, la présente invention fonctionne grâce à l'utilisation d'un dispositif d'assemblage en paquets 100. Le dispositif d'assemblage en paquets 100 fait partie du moteur d'émulation 60. La Figure 3 est un schéma fonctionnel montrant les composants d'un moteur d'émula tion 60, disposant d'un préprocesseur d'émulation 80 et d'un dispositif d'assemblage en paquets 100. Le moteur d'émulation 60 traite une séquence d'opérations (XUOP). Entre le préprocesseur d'émulation 80 et le dispositif d'assemblage en paquets 100 se trouve une file d'attente XUOP 110, également appelée tampon XUOP. Dans le préprocesseur d'émulation 80 se trouve une mémoire morte de microcode (uROM) 90. La uROM 90 fournit des informations au dispositif d'assemblage en paquets 100. La fonction du dispositif d'assemblage en paquets 100 consiste à prendre les XUOP et d'autres informations (y compris des ZUOP) fournies par le préprocesseur d'émulation 80 dans le moteur d'émulation 60, à convertir ces informations en un paquet de 16 octets valable, tel que défini par l'ISA RISC, et à fournir au moteur d'exécution 40 deux paquets de 16 octets et les bits de décodage préliminaire associés qui peuvent être décodés et exécutés en parallèle sans violer des dépendances architecturales dans la paire de paquets. La Figure 4 montre un format de paquet, avec trois syllabes de 41 bits et un modèle de 5 bits. Le préprocesseur d'émulation 80 est nécessaire pour fournir les bits d'information suivants (appelés "ZUOP"), en plus d'autres informations non décrites ici. Ces ZUOP doivent être utilisées par le dispositif d'assemblage en paquets 100 lorsqu'il crée les deux paquets de 16 octets. 1. Syllable : instruction de 41 bits qui est comprise par le moteur d'exécution 40. 2. Immediate : champ immédiat de 32 bits qui peut être utilisé comme un opérande. 3. Op-Type : champ de 3 bits spécifiant quelles unités fonctionnelles peuvent exécuter ce type de Syllable. 4. Sub-Type : champ de 3 bits spécifiant des informations supplémentaires spécifiques â un Op-Type particulier. 5. Bnd-Hint : champ de 2 bits indiquant certaines restrictions de dépen dance entre cette Syllable, ses Syllables précedentes et suivantes. 6. Reg-Valid : champ de 4 bits spécifiant si chacun de quatre champs séparés dans fa Syllable de 41 bits contient des identificateurs de registre valables. La Figure 5 montre le fonctionnement du dispositif d'assemblage en paquets 100 lorsqu'il détermine combien de XUOP il faut émettre. Le dispositif d'assemblage en paquets 100 émet 0, 1 ou 2 XUOP par groupe d'émission. Le dispositif d'assemblage en paquets 100 essaie d'émettre deux XUOP en même temps, si possible. Cette détermination est basée sur le nombre de XUOP dans la file d'attente XUOP 110 et sur l'application de certaines règles, décrites ci-dessous. Le dispositif d'assemblage en paquets doit d'abord déterminer combien d'entrées se trouvent dans la file d'attente XUOP 110, dans une fonction de détermination 200. Si la file d'attente XUOP 110 n'a pas d'entrées, alors le dispositif d'assemblage en paquets 100 ne sort rien, comme le montre la fonction de sortie de zéro XUOP 210. Si la file d'attente XUOP 110 dispose d'une entrée, alors une fonction de détermination 220 détermine si Bnd-Hint indique que deux XUOP doivent être émises en parallèle. S'il n'est pas nécessaire d'émettre deux XUOP en parallèle, alors la XUOP unique dans la file d'attente XUOP 110 est distribuée en deux paquets de 16 octets dans la fonction de sortie d'une seule XUOP 230. Si la fonction de détermination 220 détermine qu'il est nécessaire d'émettre deux XUOP en parallèle, alors le dispositif d'assemblage en paquets 100 ne sort rien dans la fonction de sortie de zéro XUOP 210. Si la file d'attente XUOP 110 dispose de deux entrées, alors une fonction de détermination 240 détermine si Bnd-Hint indique que deux XUOP doivent être émises en parallèle. Si la fonction de détermination 240 détermine que 2 XUOP doivent être émises en parallèle, alors deux XUOP sont distribuées en deux paquets de 16 octets dans la fonction de sortie de deux XUOP 250. Si la fonction de détermination 240 détermine qu'il n'est pas nécessaire d'émettre deux XUOP en parallèle, alors la fonction de détermination 260 détermine si l'une des cinq règles suivantes s'applique 1. Un bit spécifique dans un registre spécifique à la machine est positionné pour restreindre l'émission double. 2. Les deux XUOP sont prévues pour la même unité d'exécution, à moins qu'elles ne soient toutes les deux des opérations en virgule flottante ou si toutes les deux sont des opérations d'UAL "générales". 3. Les deux XUOP ont un Sub-Type qui indique qu'elles modifient des ressources de pile en virgule flottante (FP). 4. Les deux XUOP ont un Sub-Type qui indique qu'elles pourraient purger le pipeline sur la base d'un résultat de comparaison. 5. La comparaison des champs de registre qui sont indiqués comme étant valables par les bits Reg-Valid montre qu'il existe un risque de dépendance de registre entre deux XUOP. Si aucune des cinq règles ne s'applique, alors deux XUOP sont distribuées en deux paquets de 16 octets dans la fonction de sortie de deux XUOP 250. Si l'une quelconque de ces cinq règles s'applique effectivement, alors une XUOP est distribuée en deux paquets de 16 octets, dans la fonction de sortie d'une XUOP 230. TRANSFERT D'INFORMATIONS SUPPLÉMENTAIRES Dans un mode de réalisation préféré, la présente invention transfère également des informations supplémentaires entre le moteur d'émulation 60 et le moteur d'exécution 40. Dans un mode de réalisation, le champ Immediate de 32 bits est transféré du préprocesseur d'émulation 80 au moteur d'exécution 40. L'ISA RISC dispose d'un modèle de mémoire, immédiat long, à base d'entiers (MLI). En mode natif, ce modèle spécifie que la troisième Syllabe comprise dans le paquet de 128 bits est une instruction à base d'entiers qui agit sur un champ Immediate de 64 bits, dont 23 bits sont contenus dans la troisième Syllabe (1) et 41 bits sont contenus dans fa deuxième Syllabe (L). Le moteur d'exécution 40 est conçu pour interpréter le modèle MLI différemment lorsqu'il est en mode émulation. En mode émulation, la troisième Syllabe contient une instruction à base d'entiers qui agit sur un champ Immediate de 32 bits, qui sont tous contenus dans la deuxième Syllabe. Dans un mode de réalisation, fa présente invention utilise le modèle MLI pour envoyer des informations supplémentaires entre le moteur d'émula tion 60 et le moteur d'exécution 40. Dans un autre mode de réalisation de la présente invention, des informations supplémentaires peuvent être envoyées entre le moteur d'émulation 60 et le moteur d'exécution 40 pour des opérations en virgule flottante. Pour ces opérations, le dispositif d'assemblage en paquets 100 génère un modèle MFI. Le modèle MFI spécifie que la première syllabe comprise dans le paquet de 128 bits est une instruction de mémoire, la deuxième syllabe est une instruction en virgule flottante et la troisième syllabe est une instruction à base d'entiers. Pendant l'exécution d'une instruction FP, la deuxième syllabe contient une instruction FP, tandis que les première et troisième syllabes contiennent des NOP. Dans ce cas, des bits supplémentaires d'informations de commande sont envoyés au moteur d'exécution dans le cadre de la NOP dans la première Syllabe. Ces bits de Syllabe NOP sont normalement ignorés en mode natif, mais ils sont traités spécialement par le moteur d'exécution 40 en mode émulation. Bien que la présente invention ait été décrite en détail en se référant à certains modes de réalisation de celle-ci, des variations sont possibles. Par exemple, bien que les dimensions de certaines données, paquets, modèles et autres informations spécifiques aient été données à titre d'exemple, ces éléments spécifiques sont donnés à des fins d'illustration uniquement. Donc, la présente invention peut être réalisée dans d'autre formes spécifiques sans s'éloigner de l'esprit essentiel ou de ses attributs. Il est souhaité que les modes de réalisation décrits ici soient considérés en tout point de vue comme représentatifs, non limitatifs, et qu'il est fait référence aux revendications ci- jointes pour déterminer le domaine de l'invention. REVENDICATIONS 1. Un procédé pour mettre en oeuvre deux architectures sur une puce, comprenant les étapes consistant à (a) décoder une macro-instruction en une ou plusieurs micro-instructions, par l'utilisation d'un moteur d'émulation (60), (b) distribuer ladite une ou plusieurs micro-instructions à un moteur d'exécu tion (40), et (c) prévoir un tampon (30) capable de recevoir ladite une ou plusieurs micro-instructions provenant soit d'un moteur d'extraction (20) soit du moteur d'émulation (60) et capable de contenir la pluralité de micro- instructions avant qu'elles ne soient distribuées au moteur d'exécution (40). 2. Le procédé selon la revendication 1, comprenant en outre la sélection de ladite une ou plusieurs micro-instructions provenant du moteur d'extraction (20) ou du moteur d'émulation (60), et la distribution de ladite une ou plusieurs micro-instructions au moteur d'exécution (40). 3. Le procédé selon les revendications 1 ou 2, dans lequel le moteur d'émulation (60), (a) reçoit la macro-instruction, (b) convertit la macro-instruction en ladite une ou plusieurs micro- instructions à l'aide d'un préprocesseur d'émulation (80), (c) convertit les micro-instructions en au moins un paquet comportant au moins une syllabe, à l'aide d'un dispositif d'assemblage en paquets (100), et (d) distribue ledit au moins un paquet au moteur d'exécution (40). 4. Le procédé selon les revendications 1, 2 ou 3, dans lequel le moteur d'émulation (60) fournit un bit de décodage préliminaire au moteur d'exécution (40) en même temps que ledit au moins un paquet. 5. Le procédé selon les revendications 1, 2, 3 ou 4, dans lequel le dispositif d'assemblage en paquets (100), (a) reçoit au moins une ZUOP, (b) décode des informations comprises dans ladite au moins une ZUOP, (c) reçoit au moins une XUOP, (d) détermine combien desdites au moins une XUOP sont reçues, (e) si plus d'une XUOP est reçue, (i) détermine si une pluralité de ladite au moins une XUOP doit être émise en parallèle, et (ii) si la pluralité des instructions doit être émise en parallèle, émet en parallèle une pluralité de paquets contenant la pluralité d'instructions au moteur d'exécution (40), (iii) si la pluralité d'instructions ne doit pas être émise en parallèle, détermine s'il existe un problème particulier, et (A) si le problème particulier n'existe pas, distribue en parallèle une pluralité de paquets contenant une pluralité de XUOP au moteur d'exécution (40), (B) si le problème particulier existe effectivement, distribue une pluralité de paquets contenant une XUOP au moteur d'exécution (40), (f) si une XUOP est reçue, détermine si une pluralité de ladite au moins une XUOP doit être émise en parallèle, et (i) si la pluralité des instructions doit être émise en parallèle, ne distribue rien au moteur d'exécution (40), (ü) si la pluralité d'instructions ne doit pas être émise en parallèle, distribue une pluralité de paquets contenant ladite une XUOP au moteur d'exécution (40). 6. Le procédé selon les revendications 1, 2, 3, 4 ou 5, dans lequel le problème particulier est l'un quelconque des problèmes suivants (a) un bit spécifique dans un registre spécifique à la machine est positionné pour restreindre l'émission double ; (b) la pluralité de paquets à distribuer en parallèle est destinée à la même unité d'exécution et ne correspond pas à des opérations en virgule flottante et ne correspond pas à des opérations d'UAL générales ; (c) la pluralité de paquets dispose d'un sous-type qui indique qu'ils modifient des ressources de pile en virgule flottante ; (d) la pluralité de paquets dispose d'un sous-type qui indique qu'ils pourraient purger le pipeline sur la base d'un résultat de comparaison ; (e) un bit Reg-Valid associé à un champ de registre indique qu'il existe un risque de dépendance de registre entre la pluralité de paquets. 7. Le procédé selon les revendications 1, 2, 3, 4, 5 ou 6, dans lequel les ZUOP sont des bits d'information comprenant (a) une instruction Syllable, (b) un champ Immédiate, (c) un champ Op-Type, (d) un champ Sub-Type, (e) un champ Bnd-Hint, et (f) un champ Reg-Valid. 8. Le procédé selon les revendications 1, 2, 3, 4, 5, 6 ou 7, dans lequel le moteur d'émulation (60) transfère des informations supplémentaires au moteur d'exécution à l'aide d'un modèle. 9. Le procédé selon la revendication 8, dans lequel le modèle est un modèle MLI ou un modèle ME. 10. Le procédé selon les revendications 1, 2, 3, 4, 5, 6, 7, 8 ou 9, dans lequel le moteur d'émulation (60) comprend en outre une file d'attente XUOP (1 10).