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