FR3047577A1 - Instruction combinee d'addition et de verification de bornes - Google Patents

Abstract

L'invention est relative à un cœur de processeur comprenant, dans son jeu d'instructions, une instruction combinée d'addition et de vérification de bornes (ADDCK) ; un additionneur ; et un circuit de traitement (MUX, 42) conçu pour répondre à l'instruction combinée par l'activation d'un signal de débordement (OF) lorsque le résultat (S) de l'additionneur atteint une borne implicite ou définie dans un paramètre (n) de l'instruction combinée.

Description

Instruction combinée d'addition et de

VERIFICATION DE BORNES

Domaine L’invention est relative aux transferts de données entre deux entités, notamment dans un cas général où la consommation de données par l’une des entités n’a pas la même granularité que la production de données par l’autre entité.

Arrière-plan

La figure 1 illustre un exemple de situation de transfert de données selon des granularités différentes entre une entité productrice 10 et une entité consommatrice 12. L’entité productrice 10 peut comprendre une mémoire système SMEM, par exemple de type dynamique, stockant une succession d’unités de données U à traiter par l’entité consommatrice 12. L’entité consommatrice peut comprendre un cœur de processeur CPU conçu pour lire les unités de données à traiter dans une mémoire de travail locale WMEM.

Une unité de données U comprend de façon générale plusieurs octets. Une unité de données est, par exemple, une «structure» définie d’après le langage utilisé pour programmer le processeur. Une telle structure est définissable de façon arbitraire par le programmeur pour contenir des variables de types et longueurs différents.

Le fait que les unités de données puissent être produites avec une granularité différente de celle utilisée pour leur consommation pose des difficultés pour réaliser une coordination efficace entre production et consommation. Résumé

On prévoit de façon générale un cœur de processeur comprenant, dans son jeu d’instructions, une instruction combinée d’addition et de vérification de bornes ; un additionneur ; et un circuit de traitement conçu pour répondre à l’instruction combinée par l’activation d’un signal de débordement lorsque le résultat de l’additionneur atteint une borne implicite ou définie dans un paramètre de l’instruction combinée.

Le circuit de traitement peut être conçu pour activer le signal de débordement lorsqu’un bit du résultat courant produit par l’additionneur bascule par rapport au résultat précédent, la position du bit étant fixe ou définie par le paramètre de l’instruction combinée.

Pour cela, le signal de débordement peut être prélevé sur un bit de retenue de l’additionneur.

Selon une alternative, le circuit de traitement peut être conçu pour activer le signal de débordement lorsqu’un groupe de bits consécutifs du résultat de l’additionneur sont conformes à un motif implicite ou défini par le paramètre de l’instruction combinée.

Le circuit de traitement peut être conçu en outre pour déclencher une faute d’exécution lorsque le signal de débordement est activé, d’où il résulte que la procédure déclenchée pour traiter la faute peut être une procédure de gestion du débordement.

Selon une alternative, le circuit de traitement peut être conçu en outre pour provoquer un saut en avant systématique d’une ou plusieurs instructions lorsque le signal de débordement est inactif, et une continuation normale lorsque le signal de débordement est activé, d’où il résulte que la ou les instructions suivant immédiatement l’instruction combinée peuvent être conçues pour gérer le débordement.

Selon une autre alternative, le circuit de traitement peut être conçu en outre pour provoquer un appel de sous-programme lorsque le signal de débordement est activé, et une continuation normale lorsque le signal de débordement est inactif, d’où il résulte que le sous-programme peut être conçu pour gérer le débordement.

Le cœur de processeur peut comprendre en outre dans son jeu d’instructions des instructions de lecture avec pré- et post-incrémentation d’adresse, incluant pour l’incrémentation d’adresse une addition combinée avec une vérification de bornes.

On prévoit également un procédé de transfert de données utilisant une instruction combinée d’addition et de vérification de débordement, comprenant les étapes suivantes mises en œuvre par le processeur : allouer une page mémoire dans une mémoire de travail du processeur, pour contenir une série d’unités de données dans des emplacements consécutifs respectifs ; identifier le début d’un emplacement courant d’unité de données par un pointeur contenu dans un registre de travail du processeur ; utiliser l’emplacement courant ; exécuter une instruction combinée d’addition et de vérification de bornes pour incrémenter le pointeur, la borne de l’instruction combinée étant basée sur la taille de la page ; et exécuter une procédure de gestion de débordement en réponse à l’activation du signal de débordement.

La page peut avoir une taille qui est une puissance de 2, et une adresse multiple de la taille.

La procédure de gestion de débordement peut être programmée pour allouer une nouvelle page dans la mémoire de travail et mettre à jour le pointeur pour identifier un emplacement de départ dans la nouvelle page. L’étape d’utilisation de l’emplacement courant dans la page mémoire peut comprendre la lecture de l’unité de données contenue dans l’emplacement courant pour la transférer dans des registres du processeur, le procédé comprenant en outre les étapes consistant à transférer dans la page mémoire des unités de données fournies par une entité productrice, les unités de données ayant une taille arbitraire pouvant entraîner que la page ne contienne pas un nombre entier d’unités de données, d’où il résulte que l’activation du signal de débordement peut se produire alors que des données ont été lues au-delà de la page ; réserver une zone mémoire à la suite de la page, de taille suffisante pour contenir une unité de données complète ; et transférer un nombre entier d’unités de données suffisant à remplir la page et déborder dans la zone mémoire réservée, d’où il résulte que les données lues au-delà de la page correspondent à des données effectives d’une unité de données.

Description sommaire des dessins

Des modes de réalisation seront exposés dans la description suivante, faite à titre non limitatif en relation avec les figures jointes parmi lesquelles : • la figure 1, précédemment décrite, illustre un exemple de situation de transfert de données selon des granularités différentes entre une entité productrice et une entité consommatrice ; • la figure 2 représente schématiquement un additionneur inclus dans une unité de traitement d’un cœur de processeur, complété selon un premier mode de réalisation pour offrir une instruction combinée d’addition et de vérification de bornes ; • les figures 3 A et 3B illustrent une transition entre deux phases de lecture d’une mémoire provoquée par une instruction combinée d’addition et de vérification ; et • la figure 4 représente schématiquement un additionneur inclus dans une unité de traitement d’un cœur de processeur, complété selon un deuxième mode de réalisation pour offrir une instruction combinée d’addition et de vérification de bornes.

Description détaillée

Dans une situation telle qu’illustrée à la figure 1, le cœur de processeur CPU peut être conçu pour lire les unités de données U octet par octet dans la mémoire WMEM sans perte d’efficacité, alors qu’il ne serait pas envisageable de lire les unités de données octet par octet dans la mémoire système SMEM. Pour rentabiliser les accès à la mémoire système, souvent de type dynamique, les transferts sont généralement effectués par rafales de 2n octets contigus, par exemple 256, 512 ou 1024 octets.

Dans l’exemple de la figure 1, on suppose qu’une rafale de transfert contient un peu plus de trois unités de données U. Ainsi, une première rafale permet de transférer dans la mémoire WMEM les unités U0 à U2 et le début de l’unité U3

Le processeur CPU lit les unités de données dans la mémoire WMEM octet par octet, par exemple. En atteignant l’unité U3, qui est incomplète, il est souhaitable que le processeur détecte une condition de débordement et initie une nouvelle rafale de transfert, contenant l’unité U3 complète et les unités suivantes (U4, U5, et le début de l’unité U6).

La nouvelle rafale est placée dans la mémoire WMEM dans la continuité de la rafale précédente, comme cela est représenté. Si la fin de la mémoire WMEM est atteinte, la mémoire est utilisée de façon circulaire, l’écriture des données continuant au début de la mémoire WMEM.

On appelle ci-après une « page » une zone de 2n octets allouée dans la mémoire WMEM pour contenir une série d’unités de données en cours de traitement par le processeur. Une page peut être définie pour contenir une ou plusieurs rafales de transfert.

On reproduit ci-dessous un exemple d’opérations que l’on pourrait utiliser pour lire les unités de données et gérer le débordement de page dans un cœur de processeur classique. On utilise à titre d’exemple un jeu d’instructions disponible sur les cœurs ARM. ; code 1 LDR Rt, [Rptr, #offset] LDR Rt2, [Rptr, #offset2] LDR Rt3, [Rptr, #offset3] (Opérations sur les registres Rt, Rt2, Rt3...) ADD Rptr, Rptr, Rinc CMP Rmax, Rptr BLMI [adresse routine de gestion de débordement] (Continuer lecture unités de données)

On désigne par Rptr un registre contenant le pointeur vers le début de l’unité de données U à lire dans la mémoire de travail WMEM. Ce registre a préalablement été chargé avec l’adresse correspondante.

Les octets contenus dans l’unité de données courante U sont alors lus par une succession d’instructions notées LDR (pour « LoaD Register ») sous la forme : LDR Rt, [Rptr, toffset] Où Rt est le registre destination, et #offset est une valeur immédiate qui est ajoutée aux bits de poids faible, appelés « offset », de l’adresse contenue dans le registre Rptr pour identifier l’octet à lire ou le mot de plusieurs octets à lire.

Une fois que l’unité de données courante a ainsi été transférée dans les registres du processeur, elle peut être soumise aux opérations que le programmeur lui a réservées, non explicitées ici.

Pour lire l’unité de données suivante, le registre Rptr est d’abord incrémenté de la taille de l’unité de données qui vient d’être lue, contenue par exemple dans un registre Rinc : ADD Rptr, Rptr, Rinc L’incrément Rinc est la taille, en octets, de l'unité de données U. Cet incrément peut être fixe ou être différent pour chaque unité de données.

Une telle mise à jour du pointeur implique que les unités de données sont lues séquentiellement. Les unités de données pourraient être lues dans un ordre arbitraire, auquel cas le pointeur serait mis à jour par d’autres opérations.

En tout cas, le nouveau pointeur contenu dans le registre Rptr peut encore être dans la limite de la page, cependant si près de la limite que la nouvelle unité de données à lire est tronquée et inexploitable (comme l’unité de données U3 à la figure 1). Pour gérer cette situation, on peut exécuter les instructions suivantes à chaque incrémentation du pointeur : CMP Rmax, Rptr

Le contenu du registre Rptr est comparé au contenu d’un registre Rmax. En pratique cette instruction soustrait le contenu du registre Rptr au contenu du registre Rmax, et met à jour des variables d’état ou drapeaux du processeur pour refléter le résultat de la soustraction. Le registre Rmax peut contenir l’adresse de la fin de la page, diminuée de la taille de l’unité de données à lire. Ainsi, si la différence est positive ou nulle, l’unité de données suivante est entièrement contenue dans la page, et la lecture peut continuer par les opérations LDR précédemment décrites.

Si le résultat est négatif, ce qui est identifié par l’activation d’un drapeau noté MI, le contenu restant de la page n’est pas exploitable. On peut prévoir après l’instruction CMP une instruction d’appel conditionnel de sous-programme, sur la base du drapeau MI, par exemple l’instruction notée BLMI. Le sous-programme est alors conçu pour gérer le débordement, par exemple en transférant les unités de données suivantes dans une nouvelle page de la mémoire de travail.

La vérification de débordement de la page implique ici l’exécution d’une paire d’instructions, comparaison (CMP) et appel conditionnel (BLMI), à chaque fois qu’on lit une nouvelle unité de données dans la mémoire de travail, ce qui peut diminuer l’efficacité du code, notamment lorsque les unités de données sont de petite taille.

Le brevet US 6542990 décrit une instruction de vérification de bornes BNDCHK qui combine une comparaison et la génération d’une faute d’exécution selon le résultat de la comparaison. La faute est traitée par le système d’exploitation pour gérer la cause du débordement. Une telle instruction pourrait être exécutée à la place de la paire d’instructions CMP et BLMI après chaque addition ADD. L’instruction BNDCHK est cependant conçue pour effectuer des comparaisons dans différentes configurations, résultant en une unité de traitement complexifiée.

Pour augmenter davantage l’efficacité du code, on prévoit ci-après d’ajouter une nouvelle instruction générique au jeu d’instructions du processeur, appelée instruction combinée d’addition et de vérification de bornes, notée ADDCK. Cette instruction, une variante de la simple addition ADD, peut être conçue pour effectuer une addition en vérifiant simultanément que le résultat de l’addition ne dépasse pas une borne. (Par « simultanément », on entend que la vérification est effectuée dans le même cycle d’instruction que l’addition, c'est-à-dire que la vérification n’est pas effectuée par une instruction distincte.) La borne peut être implicite, c'est-à-dire câblée dans l’additionneur, ou explicitement définie par un paramètre de l’instruction.

Si la vérification est satisfaite, l’instruction ADDCK se comporte comme une simple addition ADD, et le programme se poursuit normalement.

Si la vérification échoue, l’instruction active un signal de débordement qui peut être mis en oeuvre de plusieurs manières. Le signal de débordement peut activer une variable d’état ou drapeau du processeur, lequel drapeau est désactivé lorsque le débordement a été géré. L’activation du drapeau de débordement peut provoquer une faute d’exécution qui cède immédiatement la main au système d’exploitation pour gérer le débordement. Le système d’exploitation cède ensuite la main au programme qui continue au point où il était.

Le drapeau de débordement peut générer une interruption du processeur, interruption qui peut être gérée de manière similaire à une faute d’exécution.

Ces deux alternatives (faute et interruption) sont relativement coûteuses en cycles d’instruction, car elles font appel au système d’exploitation. On préférera des alternatives qui appellent directement une procédure de gestion du débordement.

Ainsi, au lieu d’activer un drapeau, le signal de débordement peut provoquer l’appel d’un sous-programme à une adresse implicite ou fournie comme paramètre de l’instruction ADDCK. Le sous-programme est alors prévu par le programmeur pour gérer le débordement.

Selon une autre alternative, l’absence d’activation du signal de débordement peut provoquer un saut inconditionnel en avant d’un nombre d’instructions implicite ou défini par un paramètre de l’instruction ADDCK. L’activation du signal de débordement n’a alors aucun effet, de sorte que l’exécution continue avec les instructions suivant immédiatement l’instruction ADDCK, lesquelles instructions sont alors prévues pour gérer le débordement. Le saut peut être d’une seule instruction, auquel cas on prévoit un appel de sous-programme immédiatement après l’instruction ADDCK.

Une instruction ADDCK est générique et peut avoir de nombreux usages. Elle a été conçue à l’origine pour augmenter l’efficacité du code dans des situations du type de la figure 1. Dans l’exemple « code 1 » ci-dessus, l’instruction d’addition simple : ADD Rptr, Rptr, Rinc est alors remplacée par une instruction combinée d’addition et de vérification de bornes : ADDCK Rptr, Rptr, Rinc, n

Si l’instruction ADDCK est conçue pour provoquer un saut, l’adresse du saut peut être implicite (par exemple l’adresse deux instructions plus loin en absence de débordement) auquel cas l’instruction n’a pas besoin de paramètre supplémentaire. Si l’adresse du saut est explicite, elle pourra être fournie en cinquième paramètre ou comme « méta-paramètre », c'est-à-dire que l’instruction est alors conçue pour utiliser un registre dédié contenant l’adresse du saut.

Les instructions de comparaison CMP et d’appel conditionnel de sous-programme BLMI de l’exemple « code 1 » sont alors omises, et cela pour chaque itération de lecture d’une unité de données. On obtient à titre d’exemple les opérations suivantes : ; code 2 LDR Rt, [Rptr, #offset] LDR Rt2, [Rptr, #offset2] LDR Rt3, [Rptr, #offset3] (Opérations sur les registres Rt, Rt2, Rt3...) ADDCK Rptr, Rptr, Rinc, n (Continuer lecture unités de données)

Le paramètre n définit la borne utilisée pour la vérification. Le paramètre n pourrait identifier le registre Rmax mentionné dans l’exemple « code 1 », contenant l’adresse de fin de la page courante diminuée de la taille de l’unité de données courante. Cela impliquerait de comparer le résultat de l’addition au contenu du registre Rmax, opération relativement coûteuse en termes de matériel, puisque la comparaison est généralement effectuée par une soustraction. Une soustraction est généralement effectuée dans un processeur simple par l’additionneur unique (en utilisant la norme du complément à 1 plus 1). Cet additionneur étant déjà utilisé par l’instruction ADDCK, la comparaison nécessiterait en général un deuxième additionneur.

La figure 2 illustre schématiquement un premier mode de réalisation de circuit de vérification construit autour de l’additionneur 18 présent dans l’unité arithmétique d’un processeur simple. L’instruction à exécuter est notée ADDCK S, A, B, n où S désigne le registre recevant le résultat de l’addition, A et B désignent les registres contenant les opérandes, et n est le logarithme en base 2 de la taille de la page courante. En d’autres termes, la taille de la page est égale à 2n octets. Les bits contenus dans les registres S, A et B sont désignés par Si, aj, bk, où j et k sont des entiers désignant les poids des bits. A titre d’exemple, l’additionneur 18 est un additionneur de 32 bits comprenant 32 cellules d’addition élémentaires 20. Pour simplifier l’exposé, on suppose que l’additionneur est de type à propagation de retenue (« ripple-carry »). Chaque cellule 20, sauf la première, est un additionneur complet ayant deux entrées pour les opérandes ai, bi, une entrée de retenue cm, une sortie de résultat Si, et une sortie de retenue Ci reliée à l’entrée de retenue de la cellule suivante. La première cellule diffère en ce qu’elle n’a pas d’entrée de retenue.

La taille des pages étant de 2n, et les adresses des pages étant des multiples de la taille, la commutation d’un page à la suivante se traduit par le basculement du bit de rang n+1 dans l’adresse. Il suffit alors de détecter le basculement du bit de rang n+1 dans le résultat de l’addition S pour activer le signal de débordement que l’on notera OF.

En supposant que le registre de pointeur Rptr est à la fois le registre destination (S) et le premier opérande (A), une porte OU-exclusif recevant les bits an+i et sn+i fournit alors directement le signal de débordement OF.

Cependant, ce choix contraint l’utilisation de l’instruction et la rend asymétrique quant aux opérandes. Le même résultat peut être obtenu sans ces contraintes en prélevant le signal de débordement OF sur le bit de retenue cn. En effet, compte tenu que les incréments sont inférieurs à 2n, et donc que tous les bits de rang supérieur à n-1 de l’opérande correspondant sont nuis, le passage à 1 du bit de retenue cn entraîne systématiquement le basculement du bit sn+i.

Si on choisit une taille de page fixe pour le système, par exemple de 210 = 1024 octets, le paramètre n de l’instruction ADDCK peut être omis et le signal de débordement OF est directement prélevé sur le bit de retenue cio.

La figure 2 illustre plus en détail un exemple permettant de mettre en œuvre un paramètre n variable de 8 à 11, et donc de choisir des pages de 256, 512, 1024 ou 2048 octets. Le bit de retenue es à en à utiliser comme signal de débordement OF est sélectionné par un multiplexeur MUX commandé par le paramètre n. Comme on l’a déjà mentionné, le signal OF peut activer une variable d’état ST du processeur et, par exemple, déclencher une faute d’exécution servant à lancer une procédure de gestion du débordement.

Avec cette structure, lorsque le pointeur identifie une unité de données incomplète à la fin de la page, comme l’unité U3 à la figure 1, le débordement n’est pas encore signalé, puisque le pointeur est dans les limites de la page. Le débordement sera signalé à l’incrémentation suivante, alors que l’unité de données incomplète (U3) aura été lue par le processeur. Dans ce cas, la procédure de gestion de débordement pourrait être conçue pour annuler les effets de la lecture de la dernière unité de données. Pour éviter cette complication, on peut procéder de la manière exposée ci-après.

Les figures 3A et 3B illustrent une transition entre la lecture d’une page et la préparation de la page suivante à la suite de l’exécution d’une instruction ADDCK. A la figure 3A une première page PG1 est allouée dans la mémoire WMEM, par exemple en partant du début de la mémoire. Les unités de données sont transférées dans la mémoire par rafales ou unités de transfert TU dont la taille est choisie pour être un sous-multiple de la taille d’une page, pour contenir complètement au moins une unité de données, et pour offrir une efficacité de transfert suffisante à partir de l’entité productrice (par exemple une mémoire dynamique). A titre d’exemple, la taille de la page peut être de 1024 octets et la taille des unités de transfert peut être de 256 octets. A la figure 3A, on a écrit dans la mémoire WMEM un nombre suffisant d’unités de transfert TU (par exemple 4) pour former la page PG1, et une unité de transfert en plus. L’ensemble des unités de transfert écrites (cinq) contient les unités de données U0 à U10. L’unité U8 déborde de la fin de la page PG1, mais elle est entièrement contenue dans la mémoire WMEM. L’instruction ADDCK est utilisée pour incrémenter un pointeur ptr à chaque lecture d’une unité de données U. Lorsque le pointeur ptr arrive à l’emplacement de l’unité U8, l’instruction ADDCK ne signale pas encore de débordement, puisque le pointeur est dans les limites de la page. La lecture de l’unité U8 démarre dans la page et se termine hors de la page. L’instruction ADDCK est ensuite exécutée pour incrémenter le pointeur ptr, qui identifie alors l’emplacement contenant l’unité U9. Le pointeur est alors hors de la page et le débordement est signalé. A la figure 3B, la procédure de gestion de débordement alloue une nouvelle page PG2 dans la mémoire WMEM à la suite de la page PG1, et lance l’écriture des données suivantes dans la nouvelle page. Le transfert démarre à partir du point où l’unité de données U8 avait été tronquée dans la première page. Cependant, comme l’unité U8 a été correctement prise en compte par le processeur, le pointeur ptr est mis à jour pour démarrer sur l’unité de données U9.

Jusqu’ici on a supposé que les unités de données U pouvaient avoir une taille variable, rendant difficile la prédiction du débordement de la page et impliquant une gestion d’unités de données pouvant être incomplètes (U8). Si toutes les unités de données ont la même taille en mémoire de 2m octets (par exemple 64), alors une page de 2n octets (par exemple 1024) contient exactement 2n'm unités de données complètes (par exemple 16).

Dans ce cas, lorsque le pointeur déborde de la page, il identifie l’emplacement suivant immédiatement la page. Il en résulte que la dernière unité de données lue était contenue complètement dans la page et qu’une procédure du type des figures 3A et 3B est inutile.

Dans ces conditions, un débordement peut également être détecté par le fait que le pointeur ptr est arrivé à la première adresse suivant la page, en d’autres termes par le fait que les bits de poids m à n-1 du pointeur sont tous à 0. Avec l’exemple considéré, on détecte que le pointeur est conforme au motif x.. .xOOOOxxxxxx, où x est une valeur quelconque.

La figure 4 représente schématiquement un additionneur 18 complété pour utiliser cette méthode de détection de débordement. Le groupe de bits de poids m à n-1 dans le résultat S, en fait les bits servant à identifier les unités de données dans une page, sont tous fournis à une porte NON-OU 42. Le signal de débordement OF est prélevé sur la sortie de la porte 42.

Si l’on souhaite exploiter différentes tailles de page et différentes tailles d’unité de données (sachant que pour une page donnée, toutes les unités de données ont la même taille), l’instruction ADDCK peut prendre un masque comme paramètre, qui identifie le groupe de bits à prendre en compte par la porte 42, les bits externes au groupe étant tous forcés à 0 pour ne pas affecter le résultat.

Dans certains processeurs, il existe des instructions qui combinent une addition à une autre opération qui n’a pas besoin de l’additionneur. Par exemple, le jeu d’instructions ARM comprend des instructions de lecture (LDR) et écriture (STR) avec pré- ou postincrémentation du registre stockant l’adresse de lecture ou écriture. Avec une préincrémentation, le registre d’adresse est d’abord incrémenté et sert ensuite à accéder à la mémoire. Avec une post-incrémentation, le registre d’adresse est d’abord utilisé pour accéder à la mémoire et incrémenté ensuite. Ces instructions peuvent être doublées de versions offrant la vérification de bornes en association avec l’addition utilisée pour incrémenter le registre d’adresse.

On a décrit jusqu’ici des exemples de transfert de données où le processeur était consommateur d’unités de données. Le processeur pourrait également être producteur d’unités de données à transférer dans la mémoire système, auquel cas, dans les exemples de code fournis, les instructions de lecture dans la mémoire de travail (LDR) sont remplacées par des instructions d’écriture dans la mémoire de travail (STR). L’instruction ADDCK peut être utilisée de manière similaire. La procédure de gestion de débordement peut alors être prévue pour vider le contenu de la page courante et allouer une page vierge pour continuer l’écriture.

De nombreuses variantes et modifications des modes de réalisation décrits ici apparaîtront à l’homme du métier. Par exemple, bien que l’on ait décrit un pointeur qui est incrémenté pour parcourir des adresses croissantes, on peut également envisager un pointeur qui est décrémenté pour parcourir des adresses décroissantes. L’opération de décrémentation n’est autre qu’une addition d’un incrément négatif à la valeur du pointeur, qui utilise une structure d’additionneur conçue pour travailler sur des nombres binaires signés. Dans le cas d’une soustraction, le signal de débordement OF dans la structure de la figure 2 est fourni par le complément du bit de retenue.

Claims (12)

1. Revendications

   1. Cœur de processeur comprenant : • dans son jeu d’instructions, une instruction combinée d’addition et de vérification de bornes (ADDCK) ; • un additionneur ; et • un circuit de traitement (MUX, 42) conçu pour répondre à l’instruction combinée par l’activation d’un signal de débordement (OF) lorsque le résultat (S) de l’additionneur atteint une borne implicite ou définie dans un paramètre (n) de l’instruction combinée.
2. 2. Cœur de processeur selon la revendication 1, dans lequel le circuit de traitement est conçu pour activer le signal de débordement (OF) lorsqu’un bit du résultat courant produit par l’additionneur bascule par rapport au résultat précédent, la position du bit étant fixe ou définie par le paramètre (n) de l’instruction combinée.
3. 3. Cœur de processeur selon la revendication 2, dans lequel le signal de débordement (OF) est prélevé sur un bit de retenue (c) de l’additionneur.
4. 4. Cœur de processeur selon la revendication 2, dans lequel le circuit de traitement (42) est conçu pour activer le signal de débordement lorsqu’un groupe de bits consécutifs du résultat de l’additionneur sont conformes à un motif implicite ou défini par le paramètre de l’instruction combinée.
5. 5. Cœur de processeur selon la revendication 1, dans lequel le circuit de traitement est conçu pour déclencher une faute d’exécution lorsque le signal de débordement est activé, d’où il résulte que la procédure déclenchée pour traiter la faute peut être une procédure de gestion du débordement.
6. 6. Cœur de processeur selon la revendication 1, dans lequel le circuit de traitement est conçu pour provoquer un saut en avant systématique d’une ou plusieurs instructions lorsque le signal de débordement est inactif, et une continuation normale lorsque le signal de débordement est activé, d’où il résulte que la ou les instructions suivant immédiatement l’instruction combinée peuvent être conçues pour gérer le débordement.
7. 7. Cœur de processeur selon la revendication 1, dans lequel le circuit de traitement est conçu pour provoquer un appel de sous-programme lorsque le signal de débordement est activé, et une continuation normale lorsque le signal de débordement est inactif, d’où il résulte que le sous-programme peut être conçu pour gérer le débordement.
8. 8. Cœur de processeur selon la revendication 1, comprenant en outre dans son jeu d’instructions des instructions de lecture avec pré- et post-incrémentation d’adresse, incluant pour l’incrémentation d’adresse une addition combinée avec une vérification de bornes.
9. 9. Procédé de transfert de données utilisant une instruction combinée d’addition et de vérification de débordement (ADDCK) selon la revendication 1, comprenant les étapes suivantes mises en œuvre par le processeur : • allouer une page mémoire dans une mémoire de travail du processeur, pour contenir une série d’unités de données (U) dans des emplacements consécutifs respectifs ; • identifier le début d’un emplacement courant d’unité de données par un pointeur contenu dans un registre de travail (Rptr) du processeur ; • utiliser l’emplacement courant ; • exécuter une instruction combinée d’addition et de vérification de bornes (ADDCK) pour incrémenter le pointeur, la borne de l’instruction combinée étant basée sur la taille de la page ; et • exécuter une procédure de gestion de débordement en réponse à l’activation du signal de débordement.
10. 10. Procédé selon la revendication 9, dans lequel la page a une taille qui est une puissance de 2, et une adresse multiple de la taille.
11. 11. Procédé selon la revendication 9, dans lequel la procédure de gestion de débordement est programmée pour allouer une nouvelle page dans la mémoire de travail et mettre à jour le pointeur pour identifier un emplacement de départ dans la nouvelle page.
12. 12. Procédé selon la revendication 9, dans lequel l’étape d’utilisation de l’emplacement courant dans la page mémoire comprend la lecture de l’unité de données contenue dans l’emplacement courant pour la transférer dans des registres du processeur, le procédé comprenant en outre les étapes suivantes : • transférer dans la page mémoire des unités de données fournies par une entité productrice, les unités de données ayant une taille arbitraire pouvant entraîner que la page ne contienne pas un nombre entier d’unités de données, d’où il résulte que l’activation du signal de débordement peut se produire alors que des données ont été lues au-delà de la page ; • réserver une zone mémoire à la suite de la page, de taille suffisante pour contenir une unité de données complète ; et • transférer un nombre entier d’unités de données suffisant à remplir la page et déborder dans la zone mémoire réservée, d’où il résulte que les données lues au-delà de la page correspondent à des données effectives d’une unité de données.