Aktualne problemy syntezy logicznej dotyczą analizy danych przy rozpoznawaniu wzorców w takich zastosowaniach jak: dystrybucja adresów IP, skanowanie wirusów, wykrywanie niepożądanych danych. T. Sasao: Index Generation Functions: Logic Synthesis for Pattern Matching Analogiczne problemy występują w analizie danych np. przy rozpoznawaniu wzorców w takich zastosowaniach jak.. Ze względu na bardzo ważne zastosowania, poświęca się tym zagadnieniom stosunkowo dużą liczbę prac naukowych Index Generation Functions: to metodyka syntezy logicznej układów cyfrowych starająca się sprostać wyzwaniom stawianym przez konieczność precyzyjnego wyodrębniania właściwych danych z ogromnej masy danych niepotrzebnych. 1

Rozpoznawanie wzorców… …polega na selekcji niewielkiej liczby indeksowanych danych 1 ogromnej liczby danych wejściowych 1 Układ selekcji Kłopot polega na tym, że na wejście układu selekcji przychodzą tysiące (setki tysięcy) innych wektorów. Jak wyłapać te prawidłowe. 011010010010111000111 011000010010111111111 1111000010010010111110 2

Kontroler dostępu do terminali Access Control 53:03:74:59:03:32 92:6D:56:26:1E:63 81:0A:97:26:44:08 73:6E:58:56:73:52 0B:97:26:34:08:76 Decydującą rolę w projektowaniu tych układów odgrywają procedury syntezy logicznej, wymagające zaawansowanych algorytmów analizy danych, a sama realizacja sprzętowa jest nieskomplikowana… Decydującą rolę w projektowaniu takich układów odgrywają procedury syntezy logicznej , wymagające zaawansowanych algorytmów analizy danych, a sama realizacja sprzętowa jest nieskomplikowana…

Układ do wykrywania wzorców x1 y1 x2 Pattern matching circuit y2 x3 y3  y4 x40 Trzeba wykryć stosunkowo niewielką liczbę wzorów spośród ogromnej liczby innych wektorów 40-bitowych… T. Sasao, Index Generation Functions: Logic Synthesis for Pattern Matching, EPFL Workshop on Logic Synthesis & Verification, Dec. 2015. 4

Jak zaprojektować układ do wykrywania wzorców? 10 wektorów 40 bitowych 0110000100010000101001100001000100001010 0101111101101010001101011111011010100011 1111010101110111000011110101011101110001 0001111000010001011100011110000100010111 0011110000000100010100111100000001000101 0111001001000100100101110010010001001001 0010001110001111001000100011100011110010 1111111111010001111000100011100011110010 1110111000110001011011101110001100010110 1010000110100100001110100001101001000011 Jak zaprojektować układ do wykrywania wzorców? T. Sasao, Index Generation Functions: Logic Synthesis for Pattern Matching, EPFL Workshop on Logic Synthesis & Verification, Dec. 2015. 5

10 wektorów 40 bitowych Trzeba znaleźć takie kolumny (najlepiej najmniejszą ilość), które ustawione obok siebie - swoimi wierszami będą reprezentowały różne wzorce 0110000100010000101001100001000100001010 0101111101101010001101011111011010100011 1111010101110111000011110101011101110001 0001111000010001011100011110000100010111 0011110000000100010100111100000001000101 0111001001000100100101110010010001001001 0010001110001111001000100011100011110010 1111111111010001111000100011100011110010 1110111000110001011011101110001100010110 1010000110100100001110100001101001000011 6

Jak wyselekcjonować… …te prawidłowe Wystarczy wybrać kolumny 6, 16, 24 i 31 0110000100010000101001100001000100001010 0101111101101010001101011111011010100011 1111010101110111000011110101011101110001 0001111000010001011100011110000100010111 0011110000000100010100111100000001000101 0111001001000100100101110010010001001001 0010001110001111001000100011100011110010 1111111111010001111000100011100011110010 1110111000110001011011101110001100010110 1010000110100100001110100001101001000011 0000 1011 1111 1110 1010 0010 0100 1100 1101 0001 Jak wyselekcjonować te prawidłowe. Wystarczy wybrać kolumny 6, 16, 24 i 31. Z merytorycznego punktu widzenia jest to problem obliczania minimalnych zbiorów argumentów dla funkcji boolowskiej. Ale jak to obliczyć ??? 7

Błyskawica http://logic.mimuw.edu.pl/~rses/ Reduction of attributes 8

Generator indeksów RSES nie potrafi tego policzyć… 2261 reduktów 1435 ms 6 8 16 22 1 7 15 25 6 22 32 40 6 22 24 27 1 6 14 28 2 19 26 33 16 17 24 31 5 24 34 36 6 16 21 34 6 16 24 31 1 5 32 39 6 22 35 39 5 28 32 40 6 24 27 32 5 16 21 34 4 14 15 25 1 2 7 35 .type fr .i 40 .o 4 .p 10 0110000100010000101001100001000100001010 0001 0101111101101010001101011111011010100011 0010 1111010101110111000011110101011101110001 0011 0001111000010001011100011110000100010111 0100 0011110000000100010100111100000001000101 0101 0111001001000100100101110010010001001001 0110 0010001110001111001000100011100011110010 0111 1111111111010001111000100011100011110010 1000 1110111000110001011011101110001100010110 1001 1010000110100100001110100001101001000011 1010 .e Możemy wrócić do przykładu, który już omawialiśmy… Program zrealizowany przez studenta (nazwany Błyskawicą) liczy wszystkie minimalne zbiory argumentów.. Nie miałem cierpliwości aby doczekać się rozwiązania liczonego algorytmem systemu RSES. RSES nie potrafi tego policzyć… 9

…znajduje wszystkie redukty najmniejsze (2261) w czasie 1435 ms. Błyskawica …znajduje wszystkie redukty najmniejsze (2261) w czasie 1435 ms. Jeden z najmniejszych reduktów x6, x16, x24 i x31 Wynik Sasao 0110000100010000101001100001000100001010 0101111101101010001101011111011010100011 1111010101110111000011110101011101110001 0001111000010001011100011110000100010111 0011110000000100010100111100000001000101 0111001001000100100101110010010001001001 0010001110001111001000100011100011110010 1111111111010001111000100011100011110010 1110111000110001011011101110001100010110 1010000110100100001110100001101001000011 0000 1011 1111 1110 1010 0010 0100 1100 1101 0001 01100 01011 11110 00011 00111 01110 00100 11111 11101 10100 10

Głównym problemem jest zatem obliczanie reduktów! Generator indeksów Zadanie takie rozwiązuje się algorytmem redukcji argumentów 5 4 x1 4 5 Układ selekcji Pamięć główna AND Pamięć pomocnicza 35 x2 35 Głównym problemem jest zatem obliczanie reduktów! 35 Komparator x2 T. Sasao, Index Generation Functions: Logic Synthesis for Pattern Matching, EPFL Workshop on Logic Synthesis & Verification, Dec. 2015. 11

Dodatkowe uproszczenie struktury Generator indeksów 5 4 4 x1 4 5 4 Układ selekcji Pamięć główna AND Pamięć pomocnicza 35 x2 36 35 36 35 Komparator x2 36 Dodatkowe uproszczenie struktury 12

Komentarz Najpilniejsze zadanie… Current Projects • Minimizers for input variables – high-speed applications – exact minimum • Functional decomposition – using multiple IGUs T. Sasao, Index Generation Functions: Logic Synthesis for Pattern Matching EPFL Workshop on Logic Synthesis & Verification, Dec. 2015. 13

Niestety… KOD 2 z 16 1100000000000000 0000000 1010000000000000 0000001 1001000000000000 0000010 1000100000000000 0000011 1000010000000000 0000100 1000001000000000 0000101 1000000100000000 0000110 1000000010000000 0000111 1000000001000000 0001000 1000000000100000 0001001 1000000000010000 0001010 1000000000001000 0001011 1000000000000100 0001100 1000000000000010 0001101 1000000000000001 0001110 0110000000000000 0001111 0101000000000000 0010000 0100100000000000 0010001 0100010000000000 0010010 0100001000000000 0010011 0100000100000000 0010100 0100000010000000 0010101 ................................................ 0000000000100100 1101011 0000000000100010 1101100 0000000000100001 1101101 0000000000011000 1101110 0000000000010100 1101111 0000000000010010 1110000 0000000000010001 1110001 0000000000001100 1110010 0000000000001010 1110011 0000000000001001 1110100 0000000000000110 1110101 0000000000000101 1110110 0000000000000011 1110111 …procedura redukcji argumentów nie zawsze jest skuteczna w redukowaniu wejść do pamięci ROM realizujących funkcje generowania indeksów Minimalna liczba argumentów dla k z n wynosi n - 1 1 2 3 4 6 7 8 9 10 11 12 13 14 15 16 1 2 3 4 5 6 7 9 10 11 12 13 14 15 16 1 2 3 4 5 6 7 8 9 11 12 13 14 15 16 1 2 3 4 5 6 7 8 9 10 11 12 14 15 16 1 2 3 4 5 6 7 8 10 11 12 13 14 15 16 1 2 3 5 6 7 8 9 10 11 12 13 14 15 16 1 3 4 5 6 7 8 9 10 11 12 13 14 15 16 1 2 3 4 5 6 8 9 10 11 12 13 14 15 16 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 1 2 3 4 5 6 7 8 9 10 12 13 14 15 16 1 2 3 4 5 6 7 8 9 10 11 12 13 15 16 14

(Linear Decomposition) Dekompozycja liniowa (Linear Decomposition) y1 = xi1 yi1 MUX n yp = xip yip . Linear Function General X n p q Łączenie argumentów w pary Zmniejszanie liczby wejść… T. Sasao, Index Generation Functions: Logic Synthesis for Pattern Matching, EPFL Workshop on Logic Synthesis & Verification, Dec. 2015. 15

Dekompozycja liniowa - ogólnie F = H(G1, G2,…, X) X reprezentuje zmienne nie biorące udziału w realizacji funkcji G Funkcję G nazywać można g-argumentem Założenie: x0 x1 xn ROM W dekompozycji liniowej stosujemy funkcje o zredukowanej liczbie argumentów, czyli minimalno-argumentowe reprezentacje funkcji F 16

Zbiory niezgodności Cpq = {x1, x3, x6,...} F: Dn  {0,1}m Cpq = {xi: aibi = 1}, gdzie ai, bi, to składowe wektorów a, b a,b{0,1}n : F(a) ≠ F(b), będą reprezentowane liczbami p,q  K = {1,..., | Dn |} x1 x2 x3  x6 xn p 1 output1  q output2 Cpq = {x1, x3, x6,...} Rodzina zbiorów Cpq - RCpq 17

Twierdzenie Dekompozycja nierozłączna: Dekompozycja wielokrotna: jest dekompozycją minimalno-argumentowej funkcji F, wtedy i tylko wtedy gdy {xi, xj}  RCpq. Dekompozycja nierozłączna: Dekompozycja wielokrotna: zmienne wejściowe współdzielone są pomiędzy dwie lub wiele bramek: {xi  xj , xj  xk}, g-argumenty są powtarzane dla rozłącznych par zmiennych: {xi  xj , xk  xl , …}. 18

Dekompozycja nierozłączna i wielokrotna Istnienie dekompozycji z funkcją {xi  xj , xj  xk}, może zostać zweryfikowane przez sprawdzenie czy zbiór zmiennych {xi, xj, xk} zawarty jest w rodzinie RCpq. Istnienie dekompozycji z funkcją {xi  xj , xk  xl}, może zostać zweryfikowane przez sprawdzenie czy zbiór zmiennych {xi, xj, xk, xl} zawarty jest w rodzinie RCpq. Uzupełnienie RCpq względem rodziny wszystkich podzbiorów o liczności równej liczności analizowanych Cpq : COM(RCpq) 19

dekompozycja wielokrotna? Przykład x1 x2 x3 x4 x5 F 1 2 3 4 5 6 7 8 9 10 11 p,q Cpq 1,6 x4 x5 1,11 x1 x4 2,8 x2 x4 2,10 x1 x3 3,6 x2 x5 3,11 x1 x2 4,6 x2 x3 COM(RCpq) x1 x5 x3 x4 x3 x5 G1 = x1  x5 G2 = x3   x4 G3 = x3   x5 G-argumenty Czy możliwa jest dekompozycja wielokrotna? 20

Przykład… Dekompozycja wielokrotna: RCpq {xi  xj , xk  xl}. x2 x3 x5 x1 x2 x4 x1 x4 x5 x1 x3 x5 x3 x4 x5 x1 x2 x5 x1 x2 x3 x1 x3 x4 x2 x3 x4 x5 x1 x2 x3 x5 x1 x2 x3 x4 x1 x2 x3 x4 x5 G1 =  F = H(G1, G2, x2) G2 =  G3 =  COM(RCpq) x1 x2 x4 x5 x1 x3 x4 x5 x1 x3 x4 x5 21

Przykład*) 1-OUT-OF-10 FUNCTION F = H(y1, y2, y3, y4, y5, y6) x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 ---------------------------------------- 1: | 1 0 0 0 0 0 0 0 0 0 | 2: | 0 1 0 0 0 0 0 0 0 0 | 3: | 0 0 1 0 0 0 0 0 0 0 | 4: | 0 0 0 1 0 0 0 0 0 0 | 5: | 0 0 0 0 1 0 0 0 0 0 | 6: | 0 0 0 0 0 1 0 0 0 0 | 7: | 0 0 0 0 0 0 1 0 0 0 | 8: | 0 0 0 0 0 0 0 1 0 0 | 9: | 0 0 0 0 0 0 0 0 1 0 | 10:| 0 0 0 0 0 0 0 0 0 1 | y1 y2 y3 y4 y5 y6 -------------------- y1 = y2 = y3 = y4 = y5 = y6 = 1 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 1 1 0 0 0 0 0 0 1 1 0 0 0 0 1 0 1 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 0 1 0 T. Sasao, Index Generation Functions: Logic Synthesis for Pattern Matching EPFL Workshop on Logic Synthesis & Verification, Dec. 2015. 22

Przykład… Brak zmiennej x2 Nowe oznaczenia… x1 x3 x4 x5 x6 x7 x8 x9 1-OUT-OF-10 FUNCTION a1 a2 a3 a4 a5 a6 a7 a8 a9 1: | 1 0 0 0 0 0 0 0 0 | 2: | 0 0 0 0 0 0 0 0 0 | 3: | 0 1 0 0 0 0 0 0 0 | 4: | 0 0 1 0 0 0 0 0 0 | 5: | 0 0 0 1 0 0 0 0 0 | 6: | 0 0 0 0 1 0 0 0 0 | 7: | 0 0 0 0 0 1 0 0 0 | 8: | 0 0 0 0 0 0 1 0 0 | 9: | 0 0 0 0 0 0 0 1 0 | 10:| 0 0 0 0 0 0 0 0 1 | Brak zmiennej x2 Nowe oznaczenia… x1 x3 x4 x5 x6 x7 x8 x9 x10 a1 a2 a3 a4 a5 a6 a7 a8 a9 23

Przykład… Cała rodzina niezgodności a1 a2 a1 a3 a1 a4 a1 a5 a1 a6 1-OUT-OF-10 FUNCTION a1 a2 a3 a4 a5 a6 a7 a8 a9 1: | 1 0 0 0 0 0 0 0 0 | 2: | 0 0 0 0 0 0 0 0 0 | 3: | 0 1 0 0 0 0 0 0 0 | 4: | 0 0 1 0 0 0 0 0 0 | 5: | 0 0 0 1 0 0 0 0 0 | 6: | 0 0 0 0 1 0 0 0 0 | 7: | 0 0 0 0 0 1 0 0 0 | 8: | 0 0 0 0 0 0 1 0 0 | 9: | 0 0 0 0 0 0 0 1 0 | 10:| 0 0 0 0 0 0 0 0 1 | 24

wszystkie możliwe zbiory trzy elementowe Przykład… Rodzina niezgodności a1 a2 a1 a3 a1 a4 a1 a5 a1 a6 a1 a7 a1 a8 a1 a9 a2 a3 a2 a4 a2 a5 a2 a6 a2 a7 a2 a8 a2 a9 a3 a4 a3 a5 a3 a6 a3 a7 a3 a8 a3 a9 a4 a5 a4 a6 a4 a7 a4 a8 a4 a9 a5 a6 a5 a7 a5 a8 a5 a9 a6 a7 a6 a8 a6 a9 a7 a8 a7 a9 a8 a9 COM(RCpq) 36 par pusty zbiór par! wszystkie możliwe zbiory trzy elementowe Wszystkie możliwe trójelementowe podzbiory zbioru: a1 a2 a3 a4 a5 a6 a7 a8 a9 25

Przykład… Nie ma żadnej dekompozycji: 1-OUT-OF-10 FUNCTION a1 a2 a3 a4 a5 a6 a7 a8 a9 1: | 1 0 0 0 0 0 0 0 0 | 2: | 0 0 0 0 0 0 0 0 0 | 3: | 0 1 0 0 0 0 0 0 0 | 4: | 0 0 1 0 0 0 0 0 0 | 5: | 0 0 0 1 0 0 0 0 0 | 6: | 0 0 0 0 1 0 0 0 0 | 7: | 0 0 0 0 0 1 0 0 0 | 8: | 0 0 0 0 0 0 1 0 0 | 9: | 0 0 0 0 0 0 0 1 0 | 10:| 0 0 0 0 0 0 0 0 1 | Nie ma żadnej dekompozycji: Nie ma żadnej dekompozycji rozłącznej wielokrotnej Natomiast ma dekompozycję nierozłączną wielokrotną dla wszystkich możliwych trójek argumentów: ai aj ak al am an ap aq ar 26

Konfrontacja z wynikiem Sasao …to również dla takich a1 a4 a5 a2 a6 a8 a3 a7 a9 …co jest zgodne z wynikiem Sasao: …który w jego artykule zapisany jest z inną kolejnością argumentów Sasao nie mógł nie natrafić na taką dekompozycję! 27

Można sprawdzić… Oczywiście również istnieje dekompozycja wg naturalnego porządku zmiennych, czyli Dane wejściowe: 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 a1 a2 a3 a4 a5 a6 a7 a8 a9 b1 b2 b3 b4 b5 b6 1 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 1 1 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 1 1 0 0 0 0 0 1 28

Dalsza kompresja… b1 b2 b3 b4 b5 b6 Rodzina niezgodności: Zbiór wszystkich możliwych par oraz zbiór „trójek” i żadnego zbioru 6 elementowego. 1 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 1 1 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 1 1 0 0 0 0 0 1 b1;b3;b4; b1;b5;b6; b1;b2;b3; b1;b2;b4; b1;b2;b5; b1;b2;b6; b2;b3;b4; b2;b5;b6; b3;b5;b6; b3;b4;b5; b3;b4;b6; b4;b5;b6; W uzupełnieniu rodziny są „trójki” b1;b3;b5; b1;b3;b6; b1;b4;b5; b1;b4;b6; b2;b3;b5; b2;b3;b6; b2;b4;b5; b2;b4;b6; i „szóstka”. b1;b2;b3;b4;b5;b6; 29

..istnieje jeszcze lepszy wynik h 1 2 3 4 5 6 7 8 9 10 1000 8 0000 0 1010 10 0010 2 1100 12 1111 15 0011 3 0100 4 0101 5 0001 1 30

Sekwencyjna kompresja argumentów 1-OUT-OF-10 FUNCTION Reducing arguments [x0, x1, x2, x3, x4, x5, x6, x7, x8] .type fr .i 9 .o 4 .p 10 100000000 0001 010000000 0010 001000000 0011 000100000 0100 000010000 0101 000001000 0110 000000100 0111 000000010 1000 000000001 1001 000000000 1010 [x0, x1, x2, x3, x4, x5, x6, x7, x8, x9] .type fr .i 10 .o 4 .p 10 1000000000 0001 0100000000 0010 0010000000 0011 0001000000 0100 0000100000 0101 0000010000 0110 0000001000 0111 0000000100 1000 0000000010 1001 0000000001 1010 Redukcja argumentów 31

Sekwencyjna kompresja argumentów Reducing arguments [x0, x1, x2, x3, x4, x5, x6, x7, x8] [x3, x4, x5, x6, x7, x8, x0 ⊕ x1, x1 ⊕ x2] .type fr .i 9 .o 4 .p 10 100000000 0001 010000000 0010 001000000 0011 000100000 0100 000010000 0101 000001000 0110 000000100 0111 000000010 1000 000000001 1001 000000000 1010 .type fr .i 8 .o 4 .p 10 00000010 0001 00000011 0010 00000001 0011 10000000 0100 01000000 0101 00100000 0110 00010000 0111 00001000 1000 00000100 1001 00000000 1010 Dekompozycja dla trzech pierwszych zmiennych Compressing arguments [0, 1, 2] 32

Sekwencyjna kompresja… Plik wejściowy Wynik kompresji .type fr .i 10 .o 4 .p 10 1000000000 0001 0100000000 0010 0010000000 0011 0001000000 0100 0000100000 0101 0000010000 0110 0000001000 0111 0000000100 1000 0000000010 1001 0000000001 1010 .type fr .i 4 .o 4 .p 10 1000 0001 1010 0010 0010 0011 1100 0100 1111 0101 0011 0110 0100 0111 0101 1000 0001 1001 0000 1010 Wykonana dekompozycja liniowa y1 = x0 ⊕ x1 ⊕ x3 ⊕ x4, y2 = x3 ⊕ x4 ⊕ x6 ⊕ x7, y3 = x1 ⊕ x2 ⊕ x4 ⊕ x5, y4 = x4 ⊕ x5 ⊕ x7 ⊕ x8 33

Podsumowanie Nowe zadania syntezy logicznej: redukcja argumentów dekompozycja liniowa dekompozycja funkcjonalna są wynikiem nie tylko specyficznej budowy układów FPGA, ale również pojawiających się nowych zastosowań w analizie danych dystrybucja adresów IP, skanowanie wirusów, wykrywanie niepożądanych danych, konwersja kodów itp. 34