Krótki opis programu pandor.exe

Transkrypt

1 Krótki opis programu pandor.exe 1. Budowa panelu głównego Po uruchomieniu programu oba pola są puste. Lewe służy do wprowadzania badanej funkcji w postaci tablicy prawdy, w prawym natomiast prezentowane są wyniki obliczeń. Lewe okno służy dodatkowo jako źródło, z którego pobierane są dane do zapisywania plików zarówno w formacie PAN, jak i po konwersji w formatach AHDL oraz VHDL. Przcisk Reset fields czyści oba pola. Działanie przycisku Convert to PAN omówię w dziale 4.2. W menu Files dostępne są funkcje drukowania zawartości lewego i prawego pola. W menu Tools można wybrać jedną z dostępnych funkcji programu redukcję liczby argumentów funkcji oraz minimalizację funkcji metodą ekspansji. Podczas obliczeń metodą ekspansji budowana jest macierz implikantów prostych funkcji, która nawet przy niewielkich funkcjach potrafi osiągać dużą liczbę kolumn. Wąskim gardłem metody ze względu na czasochłonność algorytmu jest szukanie minimalnych pokryć kolumnowych macierzy. Dlatego w celu ewentualnego zmniejszenia tej macierzy i zwiększenia szybkości obliczeń zaleca się wcześniejsze przeprowadzenie redukcji argumentów.

2 2. Format danych wejściowych Program odczytując z lewego okna tabelę funkcji działa następująco: a. Wyszukiwane są wszystkie wiersze rozpoczynające się znakiem 0, 1 lub -. b. Począwszy od lewej strony wiersza wczytywane są wszystkie znaki aż do momentu napotkania znaku innego niż 0, 1 lub -. Będą one tworzyć blok argumentów funkcji. c. Przeszukując analizowany wiersz program posuwa się w prawo, by po napotkaniu pierwszego znaku 0, 1 lub - rozpocząć wczytywanie wiersza, który będzie tworzyć blok wartości funkcji. Naturalnym ograniczeniem wczytywania jest oczywiście również koniec wiersza. d. Wszystkie wiersze z wyjątkiem bloku: Variable names: x1,x2,x3,x4,x5 Function names: y1,y2 będą ignorowane i mogą służyć jako komentarz. Minimalna i wystarczająca postać danych wejściowych może być następująca: lub też w przypadku funkcji niezupełnych: Uruchomienie przycisku Convert to PAN powoduje, że program po sprawdzeniu poprawności tablicy funkcyjnej przedstawia ją w standardowym formacie Pandora. W przypadku drugiego przykładu będzie to: Variables = 8 Functions = 2 Data lines = 16 2

3 Variable names: x1,x2,x3,x4,x5,x6,x7,x8 Function names: y1,y Zauważmy, że przy okazji Pandor rozwinął wszystkie znaki - po stronie argumentów raz zastępując każdy z nich znakiem 0, a następnie znakiem 1. Jeśli istniał wiersz, w którym po stronie wartości funkcji istnieją same znaki -, to w czasie sprawdzania poprawności funkcji będzie on usunięty. Warto zwrócić uwagę na fakt, iż w podanym przykładzie program sam wygenerował nazwy argumentów oraz wartości funkcji. Nazwy te możemy poprawić w lewym oknie w tym momencie zanim zostanie uruchomiona procedura redukcji lub ekspansji. Możemy też wprowadzić je od razu budując właściwie wejściowy plik danych. Bardzo ważne jest, aby wiersze zapowiadające wystąpienie w wierszu kolejnym definicji nazw brzmiały dokładnie tak: Variable names: oraz Function names:. W przeciwnym razie będą one zignorowane jako komentarz. Nazwy muszą być oddzielone przecinkami i podawane bez żadnej spasji. Oczywiście ich liczba musi odpowiadać podanej tablicy. W przypadku nieprawidłowości program sam wygeneruje nowe nazwy. 3. Pliki wejściowe w formacie PAN i PLA Typowym standardem zapisu funkcji boolowskich dla obliczeń w komputerowych systemach syntezy na poziomie akademickim jest tzw. standard espresso, w którym funkcje są zapisywane w plikach z rozszerzeniem *.pla. Przykładowy zapis funkcji w standardzie espresso: 3

4 .type fr.i 9.o 6.p e Pandor będzie je oczywiście akceptować i dalej przetwarzać, choć przy pierwszej nadarzającej się okazji przekonwertuje je na format *.pan, jeśli użytkownik nie uczyni tego wcześniej przy pomocy przycisku Convert to PAN. 4. Redukcja argumentów Program liczy metodą opisaną w rozdziale III. Działanie procedury pokażę na przykładzie następującego pliku wejściowego: Variables = 9 Functions = 6 Data lines = 12 Variable names: x1,x2,x3,x4,x5,x6,x7,x8,x9 Function names: y1,y2,y3,y4,y5,y W przypadku funkcji wielowartościowej pojawi się zapytanie, czy redukcja ma być przeprowadzona dla wszystkich funkcji łącznie, czy też dla każdej oddzielnie. 4

5 Przeprowadzenie redukcji dla wszystich funkcji łącznie: Wyniki obliczeń: Input data OK! REDUCTION Computing for function y1,y2,y3,y4,y5,y6 Essential variables x1,x2,x4,x6,x7,x9 Status of all variables Table C full size Table C is empty. All results as status lines Explanation od status lines "+" essential variables "-" non-essential variables "x" needless variables "c" cover variables Results consist only variables on "+" and "c" positions. All results R1 = {x1,x2,x4,x6,x7,x9} Istnieje zatem tylko jedna minimalna realizacja przy użyciu argumentów x1, x2, x4, x6, x7 oraz x9. Możliwe jest uzyskanie kilku minimalnych realizacji przy różnych doborach argumentów. Liczba argumentów będzie w każdej takiej realizacji jednakowa. Przeprowadzenie redukcji dla wszystich funkcji oddzielnie: Wyniki obliczeń: Input data OK! REDUCTION Computing for function y1 Essential variables x1,x2 Status of all variables Table C full size 5

6 Table C reduced New status of all variables xxx All results as status lines ++---cxxx Explanation od status lines "+" essential variables "-" non-essential variables "x" needless variables "c" cover variables Results consist only variables on "+" and "c" positions. All results R1 = {x1,x2,x6} Computing for function y2 Essential variables x4 Status of all variables Table C full size Table C reduced New status of all variables -x-+--xxx All results as status lines -xc+--xxx Explanation od status lines "+" essential variables "-" non-essential variables "x" needless variables 6

7 "c" cover variables Results consist only variables on "+" and "c" positions. All results R1 = {x3,x4} Computing for function y3 Essential variables x1,x2,x4,x9 Status of all variables Table C full size Table C reduced 11 New status of all variables ++x+--xx+ All results as status lines ++x+c-xx+ ++x+-cxx+ Explanation od status lines "+" essential variables "-" non-essential variables "x" needless variables "c" cover variables Results consist only variables on "+" and "c" positions. All results R1 = {x1,x2,x4,x5,x9} R2 = {x1,x2,x4,x6,x9} Computing for function y4 Essential variables x1,x2,x7 Status of all variables Table C full size Table C reduced New status of all variables 7

8 x- All results as status lines ++cc--+x- Explanation od status lines "+" essential variables "-" non-essential variables "x" needless variables "c" cover variables Results consist only variables on "+" and "c" positions. All results R1 = {x1,x2,x3,x4,x7} Computing for function y5 Essential variables x1,x2,x4 Status of all variables Table C full size Table C is empty. All results as status lines Explanation od status lines "+" essential variables "-" non-essential variables "x" needless variables "c" cover variables Results consist only variables on "+" and "c" positions. All results R1 = {x1,x2,x4} Computing for function y6 Essential variables x1,x2,x6,x9 Status of all variables Table C full size Table C is empty. All results as status lines Explanation od status lines "+" essential variables "-" non-essential variables "x" needless variables "c" cover variables Results consist only variables on "+" and "c" positions. All results R1 = {x1,x2,x6,x9} 8

9 Results for all functions Results for function y1: R1 = {x1,x2,x6} Results for function y2: R1 = {x3,x4} Results for function y3: R1 = {x1,x2,x4,x5,x9} R2 = {x1,x2,x4,x6,x9} Results for function y4: R1 = {x1,x2,x3,x4,x7} Results for function y5: R1 = {x1,x2,x4} Results for function y6: R1 = {x1,x2,x6,x9} Widzimy, że dla każdej funkcji minimalna liczba argumentów może być różna. Każda z funkcji może również posiadać kilka różnych minimalnych realizacji, tak jak w przypadku funkcji y3. Zwróćmy uwagę na to, jak wygląda teraz panel programu. Aktywne stały się przyciski < oraz > służące do przewijania wyświetlanych w lewym oknie w postaci pliku w formacie *.pan kolejnych realizacji funkcji. Oczywiście każdy z wyświetlanych plików możemy teraz poddać metodzie ekspansji. 9

10 5. Ekspansja Program liczy metodą opisaną w dziale II. Ze względu na specyfikę metody ekspansji obliczenia możliwe są tylko dla wszystkich funkcji oddzielnie. Aby nie przytaczać tu bardzo obszernych wyników obliczeń, jakie powstaną w poprzednim przykładzie, wybiorę na potrzeby ekspansji inny plik: Variables = 8 Functions = 1 Data lines = 12 Variable names: x1,x2,x3,x4,x5,x6,x7,x8 Function names: y Celowo wybrałem tabelę jednofunkcyjną, bo w przypadku tabeli wielofunkcyjnej metoda obliczeń będzie taka sama. Program wykona wtedy w pętli kolejne obliczenia dla każdej funkcji oddzielnie. Wyniki obliczeń: Input data OK! New variable names generated. New function names generated. EXPANSION Computing for function y1 Table F of function y Table R of function y

11 Table B1 of function y All minimal cover columns in table B1 of function y1: c-x--c-+ c-x---c+ --xc-c-+ --xc--c+ --x-cc-+ Current cube: k1 = ( ) All cube expansions of table B1: 1****1*0 1*****00 ***0*1*0 ***0**00 ****11*0 Table B2 of function y All minimal cover columns in table B2 of function y1: c----+c- -c---+c- --cc c--+c- ---cc c-+c- ---c-+-c Current cube: k2 = ( ) All cube expansions of table B2: 1****00* *1***00* **00*0** **0**00* ***000** ***0*00* ***0*0*1 Table B3 of function y

12 All minimal cover columns in table B3 of function y1: -xc----c Current cube: k3 = ( ) All cube expansions of table B3: **0****0 All cube expansions of function y1 and their implicants 1****1*0 ==> x1x6!x8 1*****00 ==> x1!x7!x8 ***0*1*0 ==>!x4x6!x8 ***0**00 ==>!x4!x7!x8 ****11*0 ==> x5x6!x8 1****00* ==> x1!x6!x7 *1***00* ==> x2!x6!x7 **00*0** ==>!x3!x4!x6 **0**00* ==>!x3!x6!x7 ***000** ==>!x4!x5!x6 ***0*00* ==>!x4!x6!x7 ***0*0*1 ==>!x4!x6x8 **0****0 ==>!x3!x8 Implicants table of function y All minimal cover columns: c------c----- c c--- -c-----c c c--- --c----c c------c c---c c-----c c--c c----c--- All results of function y1 y1 = x1x6!x8 +!x3!x4!x6 y1 = x1x6!x8 +!x4!x5!x6 y1 = x1!x7!x8 +!x3!x4!x6 y1 = x1!x7!x8 +!x4!x5!x6 y1 =!x4x6!x8 +!x3!x4!x6 y1 =!x4x6!x8 +!x4!x5!x6 y1 =!x4!x7!x8 +!x3!x4!x6 y1 =!x4!x7!x8 +!x4!x5!x6 y1 = x5x6!x8 +!x3!x4!x6 y1 = x5x6!x8 +!x4!x5!x6 Explanation od status lines "+" essential variables 12

13 "-" non-essential variables "x" needless variables "c" cover variables Results consist only variables on "+" and "c" positions. Podaną funkcję można zatem uprościć do postaci minimalnej składającej się tylko z dwóch implikantów prostych. W podanym przykładzie takich minimalnych rozwiązań jest aż 10. Bardzo ważne jest, że przeprowadzenie ekspansji nie ingeruje w zawartość lewego okna, jeśli jest ono podane w poprawnym formacie Pandora. Dzięki temu po przeprowadzeniu wcześniejszej redukcji zachowana zostaje możliwość przewijania kolejnych realizacji funkcji i wielokrotnego wykonywania ekspansji dla dowolnie wybranej realizacji. 6. Zapisywanie plików w formacie PAN Przed zapisaniem pliku program wykona szereg czynności sprawdzających poprawność tabeli funkcji. Jeśli nie jest ona podana w formacie Pandora, będzie przed zapisem do tego formatu przekonwertowana. 7. Zapisywanie plików w formacie PLA Jest to format flików wejściowych dla programu Espresso. Tabela będzie najpierw poddana procedurze sprawdzającej jej poprawność. Następnie konwerter na podstawie podanej tabeli stworzy plik, który powinien być zapisany z rozszerzeniem *.pla. Przykład: Zawartość lewego okna:.type fr.i 8.o 1.p e 13

14 8. Zapisywanie plików w formacie AHDL Podobnie jak w przypadku zapisu w formacie PAN tabela będzie najpierw poddana procedurze sprawdzającej jej poprawność. Następnie konwerter na podstawie podanej tabeli stworzy plik, który powinien być zapisany z rozszerzeniem *.tdf. Przykład: Zawartość lewego okna: Variables = 5 Functions = 2 Data lines = 8 Variable names: x1,x2,x3,x4,x5 Function names: y1,y Otrzymany plik *.tdf Zapisując plik nadałem mu nazwę ahdl1.tdf. Taka sama nazwa pojawia się wtedy automatycznie wewnątrz pliku. TITLE "Project Pandor ahdl1"; SUBDESIGN ahdl1 ( -- input signals in[4..0] : INPUT; -- output signals out[1..0] : OUTPUT; ) BEGIN TABLE (in[4..0]) => (out[1..0]); B"00000" => B"01"; B"00111" => B"01"; B"01010" => B"00"; B"01111" => B"01"; B"01100" => B"01"; B"00011" => B"10"; B"01000" => B"10"; B"01101" => B"11"; END TABLE; END; 14

15 9. Zapisywanie plików w formacie VHDL Podobnie jak w przy konwersji na format AHDL tabela będzie najpierw poddana procedurze sprawdzającej jej poprawność. Następnie konwerter na podstawie podanej tabeli stworzy plik, który powinien być zapisany z rozszerzeniem *.vhd. Przykład: Zawartość lewego okna: Variables = 5 Functions = 2 Data lines = 8 Variable names: x1,x2,x3,x4,x5 Function names: y1,y Otrzymany plik *.vhd LIBRARY ieee; USE ieee.std_logic_1164.all; ENTITY vhdl1 IS PORT ( in: IN STD_LOGIC_VECTOR(4 DOWNTO 0); out: OUT STD_LOGIC_VECTOR(1 DOWNTO 0) ); END vhdl1; ARCHITECTURE vhdl1_arch OF vhdl1 IS BEGIN pandor: PROCESS (in) BEGIN CASE in IS WHEN "00000" => out <= "01"; WHEN "00111" => out <= "01"; WHEN "01010" => out <= "00"; WHEN "01111" => out <= "01"; WHEN "01100" => out <= "01"; WHEN "00011" => out <= "10"; WHEN "01000" => out <= "10"; WHEN "01101" => out <= "11"; WHEN OTHERS => out <= "00"; END CASE; END PROCESS pandor; END vhdl1_arch; 15

16 10. Drukowanie danych wejściowych i wyjściowych Zawartość obu okien można wydrukować bezpośrednio korzystając z menu Files/Print left panel oraz Files/Print righ t panel. 11. Granice możliwości programu Jedynym ograniczeniem programu jest procedura szukająca minimalne pokrycia kolumnowe macierzy. Problem jest NP-zupełny, a w związku z tym bardzo czasochłonny. Procedura sprawdza kolejno możliwość pokrycia dla 1, 2, 3 kolumn. W skrajnie niekorzystnym przypadku pokrycie może być znalezione dopiero dla kombinacji wszystkich kolumn. Nastąpi to przykładowo w przypadku tabeli: Aby nie dopuścić do takiej sytuacji oraz zmniejszyć czasochłonność procedury wbudowałem w nią mechanizm redukujący tablicę według metody opisanej w dziale 1.2. Przy poszukiwaniu k-kolumnowego pokrycia n-kolumnowej macierzy trzeba wykonać n! obliczenia sprawdzające dla kombinacji. k! n k! ( ) Najbardziej czasochłone jest przeszukiwanie kombinacji, gdzie n = 2 k. Już w przypadku tablicy 30 kolumnowej przeszukanie tylko kombinacji 15 kolumnowych wymaga obliczeń. 12. Podsumowanie Minimalizacja funkcji boolowskich jest podstawową procedurą syntezy logicznej w komputerowych systemach projektowania układów cyfrowych. Skuteczność i szybkość działania tej procedury może być decydująca o jakości implementacji sprzętowych wielu systemów cyfrowych o różnorodnych zastosowaniach. Typowymi układami cyfrowymi wymagającymi stosowania w procesie ich optymalizacji procedur minimalizacji funkcji boolowskich są m.in. S-boxy układów kryptograficznych lub struktury arytmetyki rozproszonej filtrów cyfrowych [16]. Z tych powodów zagadnieniu temu poświęcano specjalne zadania badawcze niejednokrotnie sponsorowane przez renomowane instytucje, jak np. IBM. Miały one na celu opracowanie metod i algorytmów minimalizacji odpowiednich do ogromnej złożoności układów wykonywanych w zaawansowanych technologiach. Jednym z najważniejszych rezultatów tych badań jest program Espresso, opracowany na początku lat osiemdziesiątych na Uniwersytecie kalifornijskim w Berkeley. Rozbudowane procedury programu ESPRESSO weszły już dzisiaj do kanonów syntezy logicznej, a ich różnorodność i obszerność uprawnia do stosowania hasłowej nazwy: metoda espresso. W skład metody espresso wchodzą przede wszystkim procedury ekspansji, pokrycia, uzupełnienia i tautologii. Procedury te operując na zbiorach kostek 16

17 funkcji boolowskiej f = (F, R) umożliwiają obliczenie zminimalizowanego zbioru F M wg następującego schematu. Najpierw procedura ekspansji (Expand) oblicza zbiór F E = EXPAND((F, R). Następnie obliczany jest zbiór nieokreśloności D, jako uzupełnienie sumy zbiorów F i R. Obliczenia te realizuje procedura uzupełnienie (COMPLEMENT), czyli D = COMPLEMENT(F, R). Wreszcie w procedurze pokrycie (IRREDUNDANT-COVER) zbiory F E i D transformowane są do zbioru F M = IRREDUNDANT_ COVER(F E,D), uznawanego za minimalne pokrycie funkcji f. Niestety ze względu na heurystyczny sposób obliczeń uzyskany wynik F M może nie być pokryciem minimalnym, co przy wzrastającej złożoności układów realizowanych w nowoczesnych technologiach może okazać się istotną barierą. Niniejsza praca prezentuje oryginalną metodę zmniejszania złożoności obliczeniowej algorytmów minimalizacji funkcji boolowskich. Istotą tej metody jest zastosowanie algorytmu redukcji argumentów, jako oddzielnej procedury poprzedzającej właściwą minimalizację. Redukcja argumentów jest procedurą do tej pory rzadko stosowaną w komputerowych systemach syntezy logicznej. Jedną z przyczyn takiej sytuacji jest brak świadomości, że złożone układy cyfrowe są od strony pojedynczych wyjść reprezentowane funkcjami boolowskimi o znacznie nadmiarowych zależnościach wejściowych. Dodatkowo okazuje się, że redukcja tych zależności po procesie klasycznej minimalizacji jest mało skuteczna. Program Pandor opracowany w ramach niniejszej pracy pozwalając na wykonanie procesu redukcji argumentów dla pojedynczych i grupowych funkcji boolowskich przed procesem minimalizacji umożliwia efektywne wykorzystanie tego zjawiska dla wszystkich następnych procesów syntezy. Uzasadnienie skuteczności takiej strategii omówione jest w poniższych eksperymentach. Wiele funkcji nie da się zminimalizować poprzez bezpośrednie zastosowanie systematycznej procedury minimalizacji np. zmodyfikowanej ekspansji. Przykład Variables = 21 Functions = 1 Data lines = 31 Variable names: x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21 Function names: y

18 Procedura ekspansji generuje 416 implikantów prostych, co oznacza, że macierz implikantów zawiera 416 kolumn. Systematyczne szukanie minimalnego pokrycia kolumnowego jest praktycznie niewykonalne. Przykładowo sprawdzenie, czy istnieją pokrycia 3-kolumnowe 416! wymaga czyli prawie 12 milionów uruchomień procedury sprawdzającej, czy 3! 413! dla danej kombinacji kolumn istnieje pokrycie kolumnowe. Trzeba koniecznie zdawać sobie sprawę z tego jak szybko rośnie ta liczba wraz ze zwiększeniem się liczby sprawdzanych kolumn. W naszym 416-kolumnowym przykładzie: n k n! k! n k! ( ) Najbardziej czasochłonne jest sprawdzenie połowy spośród całkowitej liczby kolumn. W naszym przykładzie w celu sprawdzenia pokrycia wszystkich kombinacji 208-kolumnowych trzeba wykaonać następującą liczbę operacji sprawdzających:

19 123 Jest to w przybliżeniu 6,6 10. Procedura reducji zmniejsza w podanym przykładzie liczbę argumentów z 21 do 5- ciu. Dla każdej z pięcioargumentowych realizacji funkcji z osobna można teraz bez problemu przeprowadzić minimalizację metodą ekspansji. Porównanie wyników programów Espresso i Pandor Przykład 1 (funkcja TL27.pla).type fr.i 10.o 1.p e Wyniki obliczeń programu Espresso:.i 10.o 1.p e 19

20 Jak widać, program Espresso potrafił zredukować zadaną funkcję do liczby 9 argumentów. Funkcja ta składa się z 6 termów. y =!x5!x6x8 +!x1!x2!x9 + x5!x6!x8!x9 + x4!x7x10 + x7!x9 + x6x7x10 Wyniki obliczeń programu Pandor: All results R1 = {x1,x2,x4,x5,x6,x7,x10} R2 = {x1,x2,x4,x6,x7,x8,x10} R3 = {x1,x2,x4,x6,x7,x9,x10} R4 = {x1,x4,x5,x6,x7,x9,x10} R5 = {x1,x4,x6,x7,x8,x9,x10} R6 = {x1,x5,x6,x7,x8,x9,x10} R7 = {x2,x3,x4,x5,x6,x7,x10} R8 = {x2,x3,x5,x6,x7,x8,x10} R9 = {x3,x4,x5,x6,x7,x9,x10} R10 = {x3,x5,x6,x7,x8,x9,x10} Jak widać, program Pandor potrafił zredukować zadaną funkcję do liczby 7 argumentów. Każdą z otrzymanych realizacji możemy poddać procedurze ekspansji. Dla kilku różnych realizacji otrzymujemy rozwiązania składające się tylko z 5 termów, a każdy z nich wykorzystuje tylko 7 argumentów. Przykładowo dla realizacji R3 otrzymamy 5 bardzo prostych termów: y1 =!x1x10 +!x1!x2!x7 +!x1!x4!x6 + x7!x9 + x1x2x4 y1 =!x1x10 +!x1!x2!x9 +!x1!x4!x6 + x7!x9 + x1x2x4 Przykład 2 (funkcja KAZ.pla).type fr.i 21.o 1.p

21 end Wyniki obliczeń programu Espresso:.i 21.o 1.p e Jak widać, program Espresso potrafił zredukować zadaną funkcję do liczby 9 argumentów, na którą składają się łącznie 3 termy: y =!x2x14!x19x21 +!x8!x11!x12 + x5x8!x20 Wyniki obliczeń programu Pandor: All results R1 = {x1,x5,x8,x10,x15} R2 = {x2,x4,x5,x9,x18} R3 = {x2,x4,x5,x18,x21} R4 = {x2,x4,x7,x9,x16} R5 = {x2,x4,x7,x9,x19} R6 = {x2,x4,x9,x10,x19} R7 = {x2,x4,x9,x13,x19} R8 = {x2,x4,x9,x15,x19} R9 = {x2,x4,x9,x17,x19} R10 = {x2,x4,x9,x18,x19} R11 = {x2,x4,x9,x19,x20} R12 = {x2,x4,x10,x19,x21} R13 = {x2,x4,x16,x17,x21} R14 = {x2,x5,x8,x17,x21} R15 = {x2,x9,x11,x19,x20} R16 = {x2,x11,x16,x17,x21} R17 = {x3,x5,x8,x10,x15} R18 = {x4,x5,x8,x10,x15} R19 = {x4,x7,x8,x9,x19} R20 = {x4,x7,x9,x12,x19} R21 = {x4,x7,x9,x16,x19} R22 = {x4,x9,x11,x13,x16} R23 = {x4,x9,x12,x17,x19} R24 = {x4,x9,x14,x16,x17} R25 = {x4,x9,x16,x17,x19} R26 = {x4,x10,x15,x17,x19} R27 = {x4,x11,x12,x13,x16} 21

22 R28 = {x4,x16,x17,x19,x21} R29 = {x5,x8,x10,x11,x15} R30 = {x5,x8,x10,x12,x15} R31 = {x5,x8,x10,x15,x17} R32 = {x5,x8,x10,x15,x19} R33 = {x5,x8,x12,x13,x14} R34 = {x8,x10,x15,x19,x20} R35 = {x10,x15,x17,x19,x20} Jak widać, program Pandor potrafił zredukować zadaną funkcję do liczby 5 argumentów, przy czym znalazł wszystkie 35 minimalnych realizacji funkcji. Poddanie procedurze ekspancji realizacji R11 daje w wyniku tylko 3 termy, a wykorzystują one łącznie tylko 5 argumentów. y1 =!x2x4!x9 + x2x19!x20 +!x2!x4x9!x19 y1 =!x2x4!x9 + x2x19!x20 +!x2x9!x19!x20 Przykład 3 (funkcja LeI20.pla) Variables = 20 Functions = 1 Data lines = 40 Variable names: x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20 Function names: y

23 Program espresso daje następujący wynik:.i 20.o 1.p e Zminimalizowana funkcja używa 10 argumentów, które składają się na 5 termów funkcji: y1 =!x11!x15x16 +!x11!x17x18 + x1!x4!x6!x13 +!x8x17!x18 +!x1x15!x17 Program Pandor daje następujące wyniki: Po redukcji argumentów: Program generuje wszystkie możliwe minimalne ze względu na liczbę agrumentów realizacje funkcji, które są funkcjami tylko 6-argumentowymi: R1 = {x1,x2,x3,x6,x11,x17} R2 = {x1,x2,x4,x8,x13,x17} R3 = {x1,x2,x6,x11,x17,x18} R4 = {x1,x2,x8,x17,x18,x19} R5 = {x1,x2,x11,x17,x18,x19} R6 = {x1,x3,x4,x6,x8,x20} R7 = {x1,x3,x6,x8,x9,x20} R8 = {x1,x4,x5,x7,x12,x14} R9 = {x1,x4,x6,x8,x13,x20} R10 = {x1,x4,x8,x11,x13,x17} R11 = {x1,x5,x6,x9,x12,x13} R12 = {x1,x5,x9,x12,x13,x17} R13 = {x1,x8,x13,x14,x17,x18} R14 = {x2,x3,x6,x8,x17,x19} R15 = {x2,x3,x8,x13,x14,x15} R16 = {x2,x3,x8,x13,x17,x19} R17 = {x2,x3,x8,x17,x19,x20} R18 = {x2,x4,x7,x9,x13,x14} R19 = {x2,x4,x8,x13,x14,x17} R20 = {x2,x5,x6,x12,x13,x16} R21 = {x2,x5,x12,x13,x14,x16} R22 = {x2,x5,x12,x13,x16,x17} R23 = {x2,x8,x13,x16,x17,x18} R24 = {x2,x10,x12,x13,x17,x19} R25 = {x3,x4,x7,x9,x12,x17} R26 = {x3,x4,x8,x17,x19,x20} 23

24 R27 = {x3,x6,x7,x8,x9,x20} R28 = {x3,x6,x8,x9,x16,x20} R29 = {x3,x6,x8,x9,x19,x20} R30 = {x3,x8,x9,x14,x19,x20} R31 = {x3,x8,x9,x17,x19,x20} R32 = {x3,x8,x13,x14,x17,x18} R33 = {x3,x8,x14,x17,x19,x20} R34 = {x4,x7,x8,x10,x14,x17} R35 = {x4,x7,x8,x14,x17,x19} R36 = {x4,x7,x10,x13,x14,x17} R37 = {x4,x8,x10,x13,x14,x17} R38 = {x4,x8,x13,x14,x17,x18} R39 = {x5,x6,x7,x9,x12,x13} R40 = {x5,x6,x9,x12,x13,x16} R41 = {x6,x7,x8,x14,x17,x19} R42 = {x6,x7,x9,x13,x16,x20} R43 = {x6,x8,x9,x13,x16,x20} R44 = {x6,x8,x9,x14,x19,x20} R45 = {x6,x8,x9,x16,x19,x20} R46 = {x7,x8,x9,x11,x14,x15} R47 = {x7,x8,x9,x14,x15,x19} R48 = {x7,x8,x9,x14,x17,x19} R49 = {x7,x8,x9,x14,x19,x20} R50 = {x7,x8,x14,x15,x17,x19} R51 = {x7,x8,x14,x17,x18,x19} R52 = {x7,x9,x13,x14,x16,x17} R53 = {x7,x10,x13,x14,x16,x17} R54 = {x7,x11,x13,x14,x17,x18} R55 = {x8,x9,x10,x14,x19,x20} R56 = {x8,x9,x11,x14,x15,x20} R57 = {x8,x9,x13,x14,x16,x17} R58 = {x8,x9,x13,x14,x17,x18} R59 = {x8,x9,x13,x14,x19,x20} R60 = {x8,x9,x14,x15,x19,x20} R61 = {x8,x9,x14,x16,x19,x20} R62 = {x8,x9,x14,x18,x19,x20} R63 = {x8,x10,x13,x14,x16,x17} R64 = {x8,x10,x13,x14,x19,x20} R65 = {x8,x11,x13,x14,x17,x18} R66 = {x8,x13,x14,x15,x17,x18} R67 = {x8,x13,x14,x15,x17,x19} R68 = {x8,x13,x14,x16,x17,x18} R69 = {x8,x13,x14,x17,x18,x19} R70 = {x11,x13,x14,x15,x17,x18} R71 = {x11,x13,x14,x15,x18,x20} R72 = {x11,x14,x15,x16,x18,x20} Każdą z powyższych realizacji możemy poddać procedurze ekspansji. Wniosek: Program Pandor znalazł szereg minimalizacji funkcji, które mają 6 argumentów (Espresso ma ich 10). W przypadku używania programu Pandor do projektowania wszelkiego rodzaju układów sekwencyjnych lub kombinacyjnych jesteśmy w stanie utworzyć rozwiązanie o strukturze najprostszej ze wszystkich możliwych. 24

25 Bardzo często ma to zdecydowany wpływ na koszty produkcji, zwłaszcza gdy mamy do czynienia z elementami produkowanymi masowo jak na przykład układy scalone. I jakkolwiek celem niniejszej pracy nie były realizacje praktycznych układów, to już można przewidywać zastosowania Pandora w zadaniach o charakterze aplikacyjnym. Typowym przykładem takich zastosowań może być redukcja argumentów bloków kombinacyjnych filtrów cyfrowych. Filtr cyfrowy 4-rzędu jest opisany tablicą prawdy o 7 wejściach i 8 wyjściach. Programem Pandor szybko można obliczyć, że w rzeczywistości poszczególne wyjścia są zależne od następujących argumentów: Results for function y1: R1 = {x1,x3,x4,x5,x7} Results for function y2: R1 = {x1,x3,x4,x5,x7} Results for function y3: R1 = {x1,x3,x4,x5,x7} Results for function y4: R1 = {x1,x3,x5,x7} Results for function y5: R1 = {x1,x3,x5,x7} Results for function y6: R1 = {x1,x3,x5,x7} Results for function y7: R1 = {x1,x3,x5,x7} Results for function y8: R1 = {x1,x3,x5,x7} Można przypuszczać, że uwzględnienie tej redukcji w dalszych zabiegach optymalizacyjnych istotnie wpłynie na realizację całego filtru. Filtr cyfrowy 7-rzędu jest opisany tablicą prawdy o 11 wejściach i 12 wyjściach. Tabela prawdy składa się z 2048 rzędów, jest to więc funkcja pełna. Programem Pandor można obliczyć, że w rzeczywistości poszczególne wyjścia są zależne od następujących argumentów: Results for function y1: R1 = {x3,x5,x6,x7,x9} Results for function y2: R1 = {x1,x3,x5,x6,x7,x9,x11} Results for function y3: R1 = {x1,x3,x5,x6,x7,x9,x11} Results for function y4: R1 = {x1,x3,x5,x7,x9,x11} Results for function y5: R1 = {x1,x3,x5,x7,x9,x11} 25

26 Results for function y6: R1 = {x1,x3,x5,x7,x9,x11} Results for function y7: R1 = {x1,x3,x5,x7,x9,x11} Results for function y8: R1 = {x1,x3,x5,x7,x9,x11} Results for function y9: R1 = {x1,x3,x5,x7,x9,x11} Results for function y10: R1 = {x1,x3,x5,x7,x9,x11} Results for function y11: R1 = {x1,x3,x5,x7,x9,x11} Results for function y12: R1 = {x1,x3,x9,x11} Uwzględnienie tej redukcji w dalszych zabiegach optymalizacyjnych istotnie wpłynie na realizację całego filtru. Przeprowadzenie redukcji dla wszystkich wyjść funkcji łącznie daje wynik: R1 = {x1,x3,x5,x6,x7,x9,x11} Program Pandor pozwala stwierdzić, że funkcja jest niezależna od argumentów x2, x4, x8 oraz x10, co wpłynie na znaczne uproszczenie dalszych obliczeń. Z 11 argumentów funkcja redukuje się do 7-miu. Oznacza to jednocześnie redukcję liczby wierszy w tabeli prawdy z 2048 do