Le processeur RISC dédié à la logique floue

M. HACHICHA,
Ecole Nationale des Ingénieurs de Sfax
Laboratoire L.E.T.I
B.P. W 3038 SFAX TUNISIE Tel : 216 74 27 40 88 Fax : 216 74 27 55 95
Email : m.hachicha@ttnet.tn

Résumé

Ce papier présente une contribution a l’implémentation d’un processeur flou (PF) dans
un FPGA en utilisant le langage de programmation VHDL.
Le processeur flou est maintenant plus que jamais une nécessitée vue que l’application de la
logique floue a touché la plupart des domaines. Le processeur flou donne un dynamisme à la
résolution des problèmes en logique floue. En effet, ce processeur présente des avantages par
rapport aux processeurs flous existants puisqu’il est basé sur l’architecture des processeurs
classiques RISC et avec son jeu d’instructions il offre une solution software a coté du
hardware.

Mots clés : processeur flou, VHDL, dynamisme, RISC.

INTRODUCTION
La logique floue a déjà fait ses preuves dans
les domaines d'applications suivants[3]
 Gestion de projet,
 Modélisation de prix, analyse
démographique des marchés
 Analyse de rentabilité pour l'achat de
compagnies,
 Gestion des aspirateurs, des systèmes de
ventilation, des machines à laver et de
régulation thermique,
 Pilotage d'un système d'autofocus
d'appareil photos et cameras vidéo,
 Système d'approche d'une station orbitale
pour la navette spatiale américaine,
 Lecture automatique, reconnaissance de
caractères,
 Traitements d'images, l’ajustement de
luminosité, de couleur et de contraste des
télévisions
De nos jours la logique floue a passé du stade
des essais aux stades des grandes réalisations .
la solution software devient indispensable a
coté du hardware. Mais, l’utilisation d’un PC
avec un processeur classique va compromettre
les performances de ces applications. d’ou il
faut un processeur flou avec des instructions
spécifiques aux applications de la logique
floue.
Dans un premier temps on va donner une idée
sur les processeurs et sur la
logique floue. Puis, nous allons
montrer comment faire le lien
entre ces derniers et les
caractéristiques correspondante.
Ensuite, a l’aide d’un programme
de test, on expliquera la méthode
de résolution des problèmes par le
processeur flou. Enfin, la
conclusion.
1- LES PROCESSEURS ET LA
LOGIQUE FLOUE
1-1- les processeurs
Le processeur (CPU) est le cerveau de
l'ordinateur, c'est lui qui fait la coordination
entre le reste des éléments, il se charge des
calculs, bref il exécute les instructions qui ont
été programmées[9].
Toutes ces opérations sont des informations
numériques.
Le processeur est en fait constitué[7]:
 d'une unité de commande qui lit les
instructions et les décode
 d'une unité de traitement (UAL - unité
arithmétique et logique) qui exécute les
instructions.
Lorsque tous les éléments d'un processeur
sont regroupés sur une même puce, on parle
alors de microprocesseur.
A chaque top d'horloge le processeur [7]:
 lit l'instruction à exécuter en mémoire
 effectue l'instruction
 passe à l'instruction suivante
Les deux grandes générations de processeurs
sont [5]:
Processeur CISC
CISC signifie "Complex Instruction Set
Computer" (machine à jeu d'instructions
complexe). Cette technologie utilise des jeux
d'instructions de longueurs variables, de
l'ordre de 160 instructions.
Vu la complexité de cette architecture, elles
prennent plus de temps à s'exécuter et
demandent parfois plus d'un cycle d'horloge .
Un processeur est cadencé par sa propre
horloge qui se mesure en MHz . Elle lui
fournit une base de temps lui servant à
cadencer les traitements.
En utilisant l'architecture CISC, le processeur
ne peut exécuter qu'une seule opération à la
fois. Il n'a qu'un seul bus le reliant à la
mémoire[6].
Processeur RISC
RISC , "Reduced Instruction Set Computer"
(machine à jeu d'instructions réduit) , a un jeu
d’instructions plus réduit que celui de CISC.
En effet, il ne comporte que 70 instructions.
Cette technologie est basée sur le fait que
chacune des instructions du processeur sera de
longueur courte et fixe, et pourra la plupart du
temps se dérouler sur un cycle d'horloge. Les
opérations arithmétiques ne s'effectuent que
sur les registres. Les informations sont
seulement déplacées d'un registre à l'autre
ceci afin d'en accélérer l'exécution et le
calcul[4]. Par ailleurs, les processeurs RISC
peuvent faire plusieurs opérations en même
temps et cela quelque soit la nature des
instructions. L'idée fondatrice de l'architecture
RISC n'est pas de réduire le nombre
d’instructions du processeur - bien que ce
dernier soit souvent inférieur à celui d'un
processeur CISC -, mais bel et bien de ne
retenir que les instructions exécutables en un
seul cycle CPU. Une instruction exécutée en
un cycle doit effectuer le chargement des
données dans les branches de l'UAL depuis
les registres ou la mémoire, puis opérer le
calcul et mémoriser le résultat. Il s'agit,
comme vous l'avez sûrement remarqué, d'une
micro-instruction.
Bien sûr, les implications sont nombreuses,
mais s'il ne faut en retenir qu'une ce doit être
que, sur une machine RISC, la diminution de
la complexité matérielle est compensée par un
compilateur très évolué.
Les processeurs CISC ont vu la taille de leur
jeu d'instructions croître de façon
exponentielle, ce qui s'est traduit par un
microprogramme très complexe. Tant que
l'accès à la mémoire centrale était pénalisant
par rapport à une lecture en mémoire morte et
un décodage de micro-instructions de plus en
plus long, l'architecture CISC était
satisfaisante. En outre, la tâche des
compilateurs était grandement simplifiée
puisqu'ils pouvaient apparier à moindre effort
les langages de programmation de haut niveau
(C, Fortran, etc.) avec un langage machine
très riche. Dans les années 80, des études
statistiques menées sur les applications ont
clairement montré que les programmes
générés par les compilateurs se contentaient le
plus souvent d'affectations, d'additions et de
multiplications par des constantes.
1-2- la logique floue
La résolution d'un problème par la logique
floue comprend 3 étapes[1][3] :
 La QUANTIFICATION "FLOUE" des
entrées / sorties du système,
 L' ETABLISSEMENT DES REGLES
liant les sorties aux entrées,
 La COMBINAISON DES REGLES pour
la génération des sorties
La première étape du traitement d'un
problème par la logique floue consiste
donc à modéliser chacune des entrées
du système par des courbes donnant
les degrés d'appartenance à différents
états identifiés pour ces entrées.
Cette étape de quantification "floue"
des variables d'entrée est aussi appelée
fuzzification.
La fuzzification des variables d'entrée est une
phase délicate du processus mis en oeuvre par
la logique floue. Elle est souvent réalisée de
manière itérative et requiert de l'expérience.
Après avoir "fuzzifier" les variables d'entrée
et de sortie, il faut établir les règles liant les
entrées aux sorties. En effet, il ne faut pas
perdre le but final que nous poursuivons qui
consiste à chaque instant, à analyser l'état ou
la valeur des entrées du système pour
déterminer l'état ou la valeur de toutes les
sorties.
La defuzzification fonctionne suivant le
principe suivant :
Plus la condition sur les entrées est vraie,
Plus l'action préconisée pour les sorties doit
être respectée. C’est en fait une combinaison
des règles selon leur degré d’activité.
2- LE PROCESSEUR FLOU
d’après ce qui précède on peut comprendre
que pour fixer les paramètres du composant
de traitement par logique floue, il faut qu’il
possède un certain dynamisme. Le processeur
flou présente la meilleure solution.
Le tableau1 résume les caractéristiques du
processeur flou
Nombre d’E/S Jusqu'à 5/2
Nombre de bits 8 bits
Nombre de MFs Jusqu'à 7
Nombre de règles Jusqu'à 16807
Fonctions Toutes les formes
d’appartenance
Facteur 5bits
d’appartenance
Nombre de modes 1
de sortie
Nombre maximum Jusqu'à 7
de chevauchement
Méthode d’inférence Yager
Defuzzification pondération
Tableau1 : caractéristiques du PF
Le processeur flou réalisée est inspirée du
processeur classique RISC puisqu’il présente
la simplicité et la robustesse.
le jeu d’instructions du processeur flou
comprend 13 instructions, conformément à la
méthodologie RISC, elles ont tous la même
taille d’un mot machine, c’est à dire 32 bits.
Pour faciliter au maximum la recherche et le
décodage des instructions, les 13 instructions
sont codées sur un format unique. Celui-ci est
composé de 4 champs indiquant le code
opération , une opérande source et une
opérande destination : donc c’est une machine
à deux opérandes.
INSTRUCTION [#]Rd [#]Rsrc
31----28 27 26 25-------18 17--------------0
Code op # # Rd ou Val Rsrc ou Val
Figure1 : format des instructions et syntaxe
Dans la syntaxe montré en figure1, instruction
représente le mnémonique de l’opération à
exécuter, [#]Rd spécifie le registre destination
parmi les 16 registres courants accessibles qui
peut être un deuxième registre source pour
certaines instructions ou une opérande
immédiate de 8 bits, [#]Rsrc le registre source
ou une opérande immédiate de 18 bits. Dans
les deux cas, la valeur immédiate est validée
si l’option « # » est active.
Les instructions du processeur flou peuvent
être divisées en 4 catégories
 Les opérations arithmétiques et
logique floue
 Les opérations de branchement
 Les opération d’accès a la mémoire
 Les opérations d’accès au bus externe
2-1- Les opérations arithmétiques et
logique floue
Les instructions de fuzzification:
 Fuzz : après la lecture de la mémoire des
antécédents, la donnée comporte 5 bits
correspondant a la valeur  et 3 bits
correspondant au code du sous ensemble
flou. La forme actuelle de cette donnée est
non significative si elle n’est pas
accompagnée du code de l’entrée. Ce
dernier sera utilisée par l’instruction fuzz
pour arranger cette donnée.
 Genere : dans le cas de chevauchement
entre deux sous ensembles flous par
variable alors, les facteurs d’appartenance
sont complémentaires par rapport à la
valeur unitaire. Pour cette raison et pour
limiter la taille de la mémoire des
antécédents ont a sauvegardé seulement
un facteur d’appartenance pour chaque
valeur de la variable. Le deuxième degrés
d’appartenance est généré par l’instruction
génère qui est une simple opération de
soustraction : 1- .
Les instructions d’inférence
 Adr_inf : elle prépare l’adresse d’une
règle qui sera utilisée pour lire ou écrire
de la mémoire des règles.
 Adr_yager1 : prépare l’adresse de la
première variable de sortie pour lire de la
mémoire des conséquences une valeur
déjà calculée par la méthode Yager.
 Adr_yager2 : prépare l’adresse de la
deuxième variable de sortie pour lire de la
mémoire des conséquences une valeur
déjà calculée par la méthode Yager.
L’instruction de defuzzification
 Defuzz : c’est la dernière étape de tout
processus en logique floue. Cette
defuzzification est partielle car elle traite
les regles deux à deux. C’est la division
d’une somme de produits par une somme
simple.
Les instructions arithmétiques
 Decr : décrémente une valeur codée sur 18
bits. Lorsque la valeur 0 est atteinte, le bit
d’état Z passe a 1.
 Reset : c’est une opération d’affectation,
elle permet d’affecter une valeur de 18
bits dans un registre.
2-2- Les instructions d’accès à la mémoire
 Store : pour écrire une donnée dans la
mémoire des antécédents ou la mémoire
des conséquences ou la mémoire des
règles.
 Load : pour lire une donnée de la mémoire
des antécédents ou la mémoire des
conséquences ou la mémoire des règles.
2-3- Les instructions d’accès au bus externe
 In : puisque dans la plupart des cas le
processeur flou dialogue directement avec
un processus réel alors, ce processeur doit
communiquer avec l’extérieur à l’aide
d’un bus externe. L’instruction In permet
d’enregistrer une valeur externe dans un
registre interne.
 Out : le résultat fourni par le processeur
flou est souvent utilisée pour commander
un processus. L’instruction Out permet le
passage d’une donnée d’un registre
interne vers l’extérieur à travers le bus
externe.
2-4- L’instruction de branchement.
 Bnez : Cette instruction permet
d’effectuer des boucles d'itérations. Le
branchement est conditionnée par le bit
d’état Z.
La figure2 représente l’architecture du PF à 3
étages de pipeline. Le premier cycle effectue
la lecture (FETCH), le décodage de
l’instruction et la préparation de la prochaine
adresse CP. Le second cycle effectue la
lecture des opérandes et l’exécution de
l’opération. C’est donc le banc de registres et
l’UAL floue qui sont activés. Enfin, le
troisième cycle stocke le résultat dans le
registre destination.
 D_mem
Bus externe Adr_ext
Retour Adr_mem
anticipé
3 WRITE
2 READ
Rd
[23:8] [7 :0]
a
Banc de Constante UAL
registres #Rd [7 :0] floue
Rsrc
Z
b Sélection
CP MUX
Constante #Rsrc[17 :0]

1 FETCH-DECODE Adresse SEQUENCEUR

programme
Figure2 :Synoptique simplifié du chemin de données du PF

Les problèmes d’interdépendance du Fuzzification de la deuxième variable

pipeline sont résolus par deux bus d’entrée
supplémentaires.
00014 IN R2 IN2
Le problème intervient lorsqu’une
00018 LOAD R3 R2
instruction utilise pour registre source, le
registre destination de l’instruction 0001C FUZZ R2 R3
précédente. Or un simple regard au schéma 00020 GENERE R3 R2
du pipeline permet de constater que ce Fuzzification de la troisième variable
dernier ne sera écrit qu’au dernier cycle. d’entrée
Les deux bus permettent donc d’intercepter
00024 IN R4 IN3
les valeurs avant leur écriture dans le banc
de registre, si une instruction en nécessite 00028 LOAD R5 R4
l’usage. 0002C FUZZ R4 R5
3- EXEMPLE DE PROGRAMME 00030 GENERE R5 R4
la partie software de ce processeur est aussi Fuzzification de la quatrième variable
évidente que la partie hardware. Dans le d’entrée
programme suivant on voit en clair les 3 00034 IN R6 IN4
étapes de la logique floue :
00038 LOAD R7 R6
00000 RESET R15 10000
0003C FUZZ R6 R7
Fuzzification de la premier variable
d’entrée 00040 GENERE R7 R6
00004 IN R0 IN1 Fuzzification de la cinquième variable
d’entrée
00008 LOAD R1 R0
00044 IN R8 IN5
0000C FUZZ R0 R1
00048 LOAD R9 R8
00010 GENERE R1 R0
0004C FUZZ R8 R9 on ne peut pas dire que le processeur flou
est un nouveau produit puisqu’il existe
00050 GENERE R9 R8
déjà sur le marché comme celui de
Préparation de l’adresse d’inférence de la Thomson[2] ou d’autres [8][9] mais, la
première règle nouveauté apportée réside dans la partie
00054 RESET R10 00000 software qui était auparavant limitée a
00058 ADR_INF R10 R0 simulé la partie hardware. Dans ce
processeur flou on a réalisé un vraie jeu
0005C ADR_INF R10 R2
d’instructions, simple, et capable de former
00060 ADR_INF R10 R4 un programme complet de traitement en
00064 ADR_INF R10 R6 logique floue.
00068 ADR_INF R10 R8 Références
Inférence [1] « Every thing you always know
0006C LOAD R11 R10 about fuzzy logic »
00070 ADR_YAGER1 R10 R11 David l Brubaker, the Huntington Group.
00074 LOAD R12 R10 EDN, March 31, 1993.
[2] « La logique floue »
00078 ADR_YAGER2 R10 R11
MM.Le van suu et Lo-presti de SGS
0007C LOAD R13 R10
Thomson, décembre 96.
La deuxième règle
[3] « Pour y voir plus clair ...
00080 RESET R10 00000 ... dans la logique floue! »
00084 ADR_INF R10 R0 http://perso.club.internet.fr/bmantel/accueil
00088 ADR_INF R10 R2 2.html.
0008C ADR_INF R10 R4
00090 ADR_INF R10 R6 [4] « Organisation et conception des
00094 ADR_INF R10 R9 ordinateurs »
D.Patterson, J.Hennessy, Paris 1994.
00098 LOAD R11 R10
[5] « Les Architectures RISC »
0009C ADR_YAGER1 R10 R11
J.C.Heudin, C.Panetto.
000A0 LOAD R14 R10
000A4 DEFUZZ R12 R14
[6] « RISC/CISC »
000A8 ADR_YAGER2 R10 R11
http://www.esige.ch/reche99/CORD9901/
000AC LOAD R11 R10 risc.htm.
000B0 DEFUZZ R13 R11
------------------- [7] « Le micro-processeur »
00EF4 OUT R12 OUT1 http://www.commentcamarche.net/pc/
00EF8 OUT R13 OUT2
00EFC DECR R15 [8] « Architecture of a 50 MFIPS Fuzzy
00F00 BNEZ 00004 processor and the related 1μm VLSI
Ce programme est simulée en utilisant le CMOS Digital Circuits »
langage de description VHDL. Dans une E.Gandolfi, M.Masetti, I.D’antone,
phase ultérieure, on va faire la synthèse sur Université de Bologne, Italie.
un FPGA.
4- CONCLUSION
[9] « High Speed Digital Fuzzy Processor
for High Energy Physics Esperiment
Triggers »