Produkte/fuzzyTECH Editionen/Benchmarks

Alle heutigen Microprozessoren und Microcontroller basieren auf der Bool'schen 0/1-Logik. Daher ist die Berechnung von Fuzzy Logic für diese Prozessoren nicht einfach und die ersten Softwareimplementationen von Fuzzy Logic waren auch sehr langsam und speicherintensiv. So benötigte beispielsweise einer der ersten veröffentlichten Fuzzy-Algorithmen auf dem 8051 Microcontroller -- dem Urvater aller Microcontroller -- etwa eine Sekunde Rechnzeit für einen Durchlauf. An schnelle Regelungssysteme war damit nicht zu denken.

Aus diesem Grund haben wir 1993 in einem mehrjährigen Gemeinschaftsprojekt mit Intel begonnen, eine Codeerzeugungstechnik zu entwickeln, die eine sehr wesentliche Beschleunigung der Fuzzy-Berechnung zur Folge hatte. So kann heute das gleiche Fuzzy-System um den Faktor 1000 schneller berechnet werden. Ein Positionsregler mit Fuzzy Logic braucht auf dem gleichen 8051 Microcontroller nur eine Millisekunde. 

Diese substantielle Beschleunigung ist auf viele Aspekte zurückzuführen. Zum einen wurde der Algorithmus der Fuzzy Logic speziell auf die Architektur von Microprozessoren hin optimiert. Hierzu verwendet der Codegenerator von fuzzyTECH eigene Rechenroutinen, die bestimmte Eigenschaften des Algorithmus und die variablen Bitlängen der Operanden optimal ausnutzen. Auch wurden alle Rechenschritte die möglich sind, auf die Compilezeit gelegt, so daß zur Laufzeit bereits alle Informationen in optimierter Form zur Verfügung stehen.

Eine besondere Bedeutung bei der Codegenerierung hat die Sortierung der Regeln durch den Codegenerator. Zur Laufzeit kann durch diese Sortierung ein Großteil der Regeln von der Berechnung ausgeschlossen werden, was die Rechenzeiten wesentlich beschleunigt. Hat beispielsweise eine Regelbasis 500 Regeln, so stellt der Code zunächst fest, welche Teile der Regelmenge bei der vorliegenden Kombination der Eingangsgrößen keinen Beitrag zum Endergebnis haben können. Dies sind in der Regel um die 90%. Bei den verbleibenden 50 Regeln wird nun überprüft, welche Regeln von anderen dominiert werden, also obwohl sie feuern, keinen Einfluß auf das Ergebnis haben. Hier können typischerweise weitere 80% der verbleibenden Regeln eliminiert werden. Letztendlich müssen dann nur 10 Regeln wirklich berechnet werden. 

Hierdurch kann der von fuzzyTECH generierte Code auch wesentlich effizienter sein, als "von Hand" erstellter. Jede Regeländerung kann eine völlig neue Strukturierung dieses Sortieralgorithmus erforderlich machen. Dieses aber manuell bei jeder Regeländerung durchzuführen stellt einen unpraktikablen Aufwand dar. 

Um Ihnen zu ermöglichen, abzuschätzen welche Rechenzeiten und Speicherbedarf Ihre Fuzzy-Lösung möglicherweise erfordert, haben wir als Benchmark 5 Fuzzy-Systeme auf unterschiedlichen Zielplattformen getestet, die aus realen Aufgabenstellungen stammen und nur leicht verallgemeinert wurden.  

Bench 4 stammt aus einer Forschungsanwendung und ist das derzeit größte veröffentlichte Fuzzy-System im Bereich des Embedded Control.

Benchmarks Bench 0 Bench 1 Bench 2 Bench 3 Bench 4
Prozessor/Mikrokontroller 7 Regeln
2 Ein / 1 Aus
20 Regeln
2 Ein / 1 Aus
20 FAM Regeln 2 Ein / 1 Aus 80 FAM Regeln 3 Ein / 1 Aus 500 FAM Regeln 8 Ein / 4 Aus
PC: fuzzyTECH Professional Edition, C Code Erzeugung, 16 bit Auflösung, Test Prozessor i486SX, 33 MHz, MS-C 8.00 0,05/0,07 ms
0,73 KB OBJ
39 Byte RAM
0,05/0,08 ms
0,82 KB OBJ
47 Byte RAM
0,05/0,09 ms
0,89 KB OBJ
47 Byte RAM
0,09/0,12 ms
1,27 KB OBJ
53 Byte RAM
0,35/0,45 ms
3,5 KB OBJ
185 Byte RAM
80C196: fuzzyTECH MCU-96 Edition, Assemblercodeerzeugung, 16 bit Auflösung, Test MCU 80C196KD, interner ROM, 20 MHz 0,19/0,23 ms
0,63 KB ROM
50 Byte RAM
0,24/0,33 ms
0,69 KB ROM
58 Byte RAM
0,26/0,38 ms
0,78 KB ROM
58 Byte RAM
0,44/0,64 ms
1,17 KB ROM
66 Byte RAM
1,87/2,45 ms
3,47 KB ROM
214 Byte RAM
80C166: fuzzyTECH MCU-166 Edition, Assemblercodeerzeugung, 16 bit Auflösung, Test MCU 80C166, interner ROM, 20 MHz 0,05/0,06 ms
0,44 KB ROM
30 Byte RAM
0,06/0,08 ms
0,56 KB ROM
30 Byte RAM
0,06/0,09 ms
0,61 KB ROM
30 Byte RAM
0,10/0,14 ms
0,99 KB ROM
36 Byte RAM
0,43/0,56 ms
3,2 KB ROM
194 B RAM
68HC11: fuzzyTECH MCU-11/12 Edition, Assemblercodeerzeugung, 8 bit Auflösung, Test 68HC11, ext. ROM, 8 MHz 1.1 ms/1.3 ms
0.64 KB ROM
31 Byte RAM
1.4ms /1.9 ms
0.71 KB ROM
35 Byte RAM
1.4 ms/1.9 ms
0.75 KB ROM
35 Byte RAM
2.6 ms/3.5 ms
1.1 KB ROM
39 Byte RAM
11 ms/14 ms
3.1 KB ROM
113 Byte RAM
68HC12: fuzzyTECH MCU-11/12 Edition, Assemblercodeerzeugung, 8 bit Auflösung, Test 68HC12, ext. ROM, 16 MHz 0.09ms/0.09ms
0.34 KB ROM
26 Byte RAM
0.14ms/0.15ms
0.42 KB ROM
30 Byte RAM
0.16ms/0.17ms
0.54 KB ROM
30 Byte RAM
0.40ms/0.41ms
1.4 KB ROM
34 Byte RAM
2.1 ms/2.2 ms
8.8 KB ROM
108 Byte RAM
TMS-320: fuzzyTECH MCU-320 Edition, Assemblercodeerzeugung, 16 bit Auflösung, Test MCU TMS-320C52, ext. ROM, 20 ns 0,02/0,022 ms
0,85 KB ROM
54 Byte RAM
0,023/0,03 ms
0,99 KB ROM
60 Byte RAM
0,024/0,03 ms
1,06 KB ROM 62 Byte RAM
0,039/0,049 ms
1,8 KB ROM
70 Byte RAM
0,146/0,188 ms
5,7 KB ROM
218 B RAM*)
8051: fuzzyTECH MCU-51 Edition, Assemblercodeerzeugung, 8 bit Auflösung, Test MCU 80C51, interner ROM, 12 MHz 1,0/1,2 ms
0,45 KB ROM
21 Byte RAM
1,4/1,9 ms
0,54 KB ROM
25 Byte RAM
1,5/2,0 ms
0,58 KB ROM
25 Byte RAM
4,4/4,9 ms
1,0 KB ROM
29 Byte RAM
16,7/18,0 ms
3,0 KB ROM
103 B RAM
PIC16C5X: fuzzyTECH MP Edition, Assemblercodeerzeugung, 8 bit Auflösung, Test MCU PIC16C74, interner ROM, 20 MHz 0,4/0,4 ms
0,32 KB ROM
27 Byte RAM
0,7/0,8 ms
0,41 KB ROM
31 Byte RAM
0,9/1,0 ms
0,44 KB ROM
31 Byte RAM
2,5/2,7 ms
0,7 KB ROM
35 Byte RAM
10,3/11,4 ms
2,2 KB ROM
107 Byte RAM
Programmable Logic Controller: fuzzyTECH IA Edition, Fuzzy-Funktionsblock, 16 bit Auflösung, Test-SPS Moeller PS4/401 -/1,6 ms
-
-
-/1,6 ms
-
-
-/1,6 ms
-
-
-/1,6 ms
-
-
-/3,0 ms
-
-

Alle Rechenzeiten (Durchschnitt/Maximum)
ms := Millisekunde