COPYRIGHT 2004 MARCIN KARWIŃSKI & MARCIN DZIĘGIELEWSKI WYSZUKIWANIA SYSTEMY INFORMACJI LIST INWERSYJNYCH METODA. 1 z 19

Transkrypt

1 1 z 19 SYSTEMY WYSZUKIWANIA INFORMACJI METODA LIST INWERSYJNYCH

2 2 z 19 Spis treści Słowo wstępne 3 Parę słów o listach inwersyjnych, czyli czym są właściwie te listy? 3 Krótka analiza wad MLP3 Redundancja w MLI czyli jak ograniczyć zajętość pamięci3 Gdzie to przyspieszenie? 4 Aktualizacja nieco utrudniona4 A gdzie ta inwersyjność?4 Klasycznie biorąc się z bykiem za rogi 4 Zadawanie pytań, uzyskiwanie odpowiedzi czyli jak to działa 5 Modyfikacje, czyli ulepszamy jedno, pogarszamy drugie bilans równa się zero ;-) 5 Modyfikacje pamięciowe5 Modyfikacje czasowe6 Trochę praktyki dla utrwalenia wiedzy, czyli trening czyni mistrza7 Przypomnienie kartoteki wtórnej, czyli jak to było7 Tworzymy funkcję adresującą 8 Tworzenie kartoteki wyszukiwawczej, czyli jeszcze raz to samo9 Kartoteka w metodzie klasycznej 9 Metoda klasyczna przykłady11 Przykład 1 wyszukiwanie określonych obiektów 11 Przykład 2 wstawianie obiektu12 Przykład 3 aktualizacja opisu obiektu12 Przykład 4 usuwanie obiektu 13 Kartoteka w MLI ze zmniejszonym zbiorem list inwersyjnych 13 Trochę teorii nie zawadzi, czyli od teoretyka do praktyka13 Właściwa kartoteka, czyli widać zmniejszenie redundancji 14 MLI ze zmniejszonym zbiorem list inwersyjnych przykłady 14 Przykład 1 wyszukanie obiektu14 Przykład 2 wstawianie nowego obiektu16 Przykład 3 aktualizacja opisu obiektu16 Przykład 4 usuwanie obiektu 17 Parametry MLI, czyli króciutkie podsumowanie18 Struktura bazy danych18 Redundancja i zajętość pamięci18 Aktualizacja bazy danych 18 Czas wyszukiwania18 Język wyszukiwania19 Tryb pracy 19 Wnioski, czyli jeszcze trochę ględzenia na koniec 19

3 3 z 19 Słowo wstępne Informatyka jest najdynamiczniej rozwijającą się nauką w dziejach ludzkości Rozwiazania stosowane kilka lat temu, dzisiaj są juz mocno przestarzałe Jest to widoczne zarówno w postępie jaki dokonał się w dziedzinie budowy sprzętu komputerowego, jak i rozwoju oprogramowania Wiąże się to oczywiscie z rozwojem i wdrażaniem nowych technologii produkcji i technik projektowania, ale taże z wykożystaniem komputerów do coraz to nowych zadań Ciągle rośnie liczba użytkowników komputerów na całym świecie co wiąże się oczywiście z rozwojem internetu Nie zdajemy sobie nawet sprawy jak wiele informacji znajduje sie w zasiegu naszej ręki Informatyka przecież to nauka o przetwarzaniu informacji Taka skarbnicą wiedzy jest internet, a kluczem przeglądarki internetowe Korzystamy z nich praktycznie za każdym razem gdy łączymy się z siecią Wymagamy nie tylko szybkiej odpowiedzi, ale chcemy, aby wskazane adresy zawierały dokładnie to czego szukamy Nie jest to proste zadanie Z podobnymi problemami stykamy sie w duzych systemach bazodanowych Ilość danych do przetworznia rośnie z roku na rok Pojawiają się także nowe ich rodzaje (zdjęcia, filmy) Powstają coraz to nowsze sposoby ich opisu Coraz częściej od czasu uzyskania jakichś danych zależą losy jakiegoś przedsiębiorstwa Zmierzamy do tego, aby pokazać, że algorytmy dobrze sprawdzajace się jeszcze kilka lat temu dzisiaj mogą być szalenie nieefektywne w użytkowaniu Poznana przez nas metoda wyszukiwania informacji, jaką niewątpliwie jest metoda przeglądu zupełnego, nie mogła dalej funkcjonować jako efektywny algorytm do zastosowania we wciąż rozwijających sie systemach bazodanowych Należało wymyśleć coś lepszego powstała więc metoda list inwersyjnych Jest bardzo szybka w porównaniu do swojej poprzedniczki Niestety kosztem szybkości inne parametry uległy pogorszeniu, ale więcej na ten temat znajduje się w naszym sprawozdaniu Parę słów o listach inwersyjnych, czyli czym są właściwie te listy? Opisy obiektów są określone przez podanie wartości cech, za pomocą których opisujemy obiekty w systemie Cechy te noszą nazwę atrybutów, a wartości, które można przporządkować obiektom w ramach jednego atrybutu, noszą nazwę deskryptorów Tyle wiemy z dotychczasowych rozważań W czym tkwi myk tej metody? Opowiedź na to pytanie znajdziemy w niniejszym rozważaniu poświęconemu najważniejszym parametrom MLP Krótka analiza wad MLP Otóż już prosta analiza procesu wyszukiwania informacji w metodzie przeglądu zupełnego prowadzi nas do zaskakująco prostego acz bardzo ważnego wniosku Zauważmy, że przy prostych pytaniach jednodeskryptorowych system oparty na MLP musi przejrzeć wszystkie obiekty, bądź część (np w przypadku modyfikacjach grupowania, odcinkowania, czy też podziału połówkowego) ich zbioru, choć stosunkowo często nawet podane modyfikacje nie pomogą jeśli w zapytaniu pojawi się atrybut, względem którego nie była przeprowadzana optymalizacja modyfikacji metody Rozwiązaniem, choć kosztownym ze względu na pewną nadmiarowość w opisach, jest utworzenie kartoteki wyszukiwawczej, w której dla każdego deskryptora w systemie tworzona jest lista obiektów zawierających w swoim opisie ten deskryptor Redundancja w MLI czyli jak ograniczyć zajętość pamięci Dla zmniejszenia zajętości pamięci, a także dla zmniejszenia redundancji, kartotekę wyszukiwawczą generujemy w taki sposób, że dla każdego deskryptora zapisywane są adresy (numery) wszystkich obiektów opisywanych przez ten deskryptor W przypadku malej liczby obiektów, a także ich krótkiej nazwy, w zamian za adresy obiektów, stosujemy ich nazwy/identyfikatory

4 4 z 19 Gdzie to przyspieszenie? Taka budowa kartoteki powoduje dużą szybkość wyszukiwania, w przypadku, gdy mamy zapytania składające się z pojedynczych deskryptorów, co też nietrudno wywnioskować z powyższego wywodu Wiadome jest, że w takich przypadkach kartoteka zbudowana z list inwersyjnych pozwala niezwykle szybko, jak na tak prostą metodę, znaleźć odpowiedź na pytanie zadane do systemu Jeżeli bowiem pytamy o obiekty mające w swoim opisie określony deskryptor, to dla znalezienia odpowiedzi wystarczy znaleźć właściwą listę inwersyjną Obiekty podane w tej liście stanowią odpowiedź na pytanie Ale też zwiększenie liczby deskryptorów nie powoduje dużej komplikacji obliczeń Jeżeli bowiem pytanie dotyczy obiektów opisanych kilkoma deskryptorami, to aby otrzymać odpowiedź, należy znaleźć listy inwersyjne dla wszystkich deskryptorów występujących w pytaniu Następnie w takich wypadkach na zbiorach odpowiedzi z pojedynczych deskryptorów wykonywana jest operacja AND lub OR Wstawianie do zapytań operatora logicznego NOT nie wiąże się również z większym problemem obliczeniowym Zatem dla znalezienia odpowiedzi na pytanie skierowane do systemu wystarczy wykonać pewne proste operacje na listach inwersyjnych (czyli w zasadzie na zbiorach) Można zauważyć, ze odpowiedzi uzyskujemy rzeczywiście szybko Aktualizacja nieco utrudniona Ponieważ obiekty pamiętane są w wielu listach, to właśnie ta nadmiarowość danych powoduje pewne utrudnienia dla procesu aktualizacji bazy danych w stosunku do przecież niezwykle prostego w wykonaniu procesu aktualizacji bazy w systemie opartym na metodzie list prostych (w tym na wszystkich modyfikacjach) Dodanie lub usunięcie elementu z bazy danych wiąże się z modyfikacją całej kartoteki wyszukiwawczej - należy usunąć adres do tego rekordu (bądź nazwę obiektu opisywanego w danym rekordzie) z wszystkich powiązanych z nim deskryptorów A gdzie ta inwersyjność? Metoda list inwersyjnych różni się od metody list łańcuchowych i metody list prostych tym, że listy łańcuchowe nie są umieszczone w opisach elementów, ale w osobnych listach Na dodatek listy te nie opisują bezpośrednio obiektów, czytaj dostęp do informacji nie biegnie od obiektu do informacji a odwrotnie (stąd właśnie ta inwersyjność), tj od wartości atrybutu do opisu obiektu, któremu funkcja informacji właśnie tą wartość przypisała Poza tym, w poprzednim przypadku listy były generowane podczas wyszukiwania, tutaj natomiast są podane bezpośrednio Klasycznie biorąc się z bykiem za rogi Podobnie do MLP mamy zdefiniowany system wyszukiwania S, a więc zbiór obiektów X, atrybutów A, wartości tych atrybutów V oraz funkcja informacji ρ Oczywiście te elementy tworzą czwórkę uporządkowaną: S = <X, A, V, ρ> Zakładamy, że obiekty opisane są iloczynem odpowiednich niezaprzeczonych deskryptorów Opisy obiektów t x umieszczone są w dowolny sposób w pamięci komputera Dodatkowo zakładamy, że mamy dużą bazę, zatem obiektom x 1,,x n odpowiadają adresy n 1,,n m Utworzyliśmy zatem pewein zbiór adresów N = {n 1,,n m } stosując funkcję adresującą μ w następujący sposób: μ: X N, przy czym μ(x)=μ (y) t x = t y co należy czytać nastepująco przypisujemy ten sam adres obiektom o takich samych opisach deskryptorowych Tworzymy listy inwersyjne (oznaczane przez α(d i )), czyli listy adresów tych obiektów, które w swoim opisie zawierają deskryptor di (d i є t x ) Zapisujemy to jako: α(d i ) = {n 1,,n z }, gdzie d i = (a i, v i ), a i є A, v i є V ai Tworzymy tyle list inwersyjnych ile mamy deskryptorów w systemie

5 5 z 19 Zadawanie pytań, uzyskiwanie odpowiedzi czyli jak to działa Pytania do tak zdefiiowanego systemu S zadajemy w postaci termu t będącego sumą termów składowych t = t 1 ++ t m Termy składowe pytania mogą być pojedynczymi deskryptorami, a więc term t jest postaci: t = d 1 + d 2 + d d k Opowiedź na pytanie t otrzymujemy bezpośrednio przez wygenerowanie list inwersyjnych dla deskryptorów występujących w pytaniu Zatem: σ(t) = α(d 1 ) u α(d 2 ) uu α(d k ) Termy składowe mają postać iloczynu deskryptorów Odpowiedź na term t jest więc sumą odpowiedzi na termy składowe: σ(t) = σ(t 1 ) u σ(t 2 ) uu σ(t m ) Odpowiedź na trm składowy t i otrzymujemy jako przecięcie (część wspólna) list inwersyjnych związanych z deskryptorami występującymi w pytaniu t i : σ(t i ) = α(d 1 ) n α(d 2 ) nn α(d k ), gdzie t i = d 1 d 2 d k Jeśli w listach inwersyjnych występowały adresy obiektów, to kolejnym krokiem będzie znalezienie obiektów odpowiadających tym adresom Ogólnie więc biorąc odpowiedź na zapytanie t, będące sumą termów składowych jest sumą odpowiedzi na termy składowe: σ(t) = σ(t 1 ) u σ(t 2 ) uu σ(t m ), przy czym σ(t i ) = {x є X, μ(x)=n i oraz n i є N' = j α(d j ), gdzie N' є N, a d j є t i } Odpowiedź na pytanie t jest sumą odpowiedzi na pytania składowe, przy czym odpowiedź na pytanie składowe uzyskujemy jako przecięcie list inwersyjnych związanych z deskryptorami występującymi w pytaniu składowym Metoda ta wnosi dużą redundancję, którą można opisać wzorem: R = ( r i=1 #α(d i ) N)/N, gdzie r liczba deskryptorów w systemie, N liczba obiektów (lub adresów), a symbol #x oznacza moc zbioru x Modyfikacje, czyli ulepszamy jedno, pogarszamy drugie bilans równa się zero ;-) Jak zwykle modyfikacje wprowadzane do metody klasycznej mają na celu zlikwidowanie jakichś wad tej pierwotnej metody, bądź też mają za zadanie polepszyć/podrasować te cechy, z których dana metoda słynie i dzięki którym jest tak szeroko wykorzystywana Już pobieżna analiza wykazuje, iż w metodzie list inwersyjnych obiekty pamiętane są wielokrotnie Wynika stąd istotna wada tej metody jest nią duża redundancja Oczywiste więc że modyfikacje w większości zostały stworzone dla zmniejszenia redundancji w systemie Modyfikacje pamięciowe Modyfikacje tej grupy mają na celu zmniejszenie zajętości pamięci przez listy inwersyjne Należą do nich proste modyfikacje związane z innym zapisem kartoteki wyszukiwawczej: zaznaczanie przedziałów elementów pamiętanie list zanegowanych tworzenie list zredukowanych dla dwóch deskryptorów: w danej liście początek odnosi się do pierwszego deskryptora, środek do obydwu, końcówka do drugiego a także te które oprócz samego zmiejszenia zajętości pamięci przyśpieszają dodatkowo dla pewnej klasy pytań funkcjonowanie systemu wyszukiwania informacji, np: MLI ze zmniejszonym zbiorem list inwersyjnych: w tej metodzie listy nie są tworzone dla wszystkich deskryptorów występujących w opisach obiektów, a dla pewnego podzbioru D' є D tych deskryptorów Wybrany podzbiór D' może być zbiorem deskryptorów najczęściej występujących w pytaniach do systemu S lub zbiorem deskryptorów pewnego atrybutu (ew Atrybutów), co jest związane z modyfikacjami MLP MLI z dekompozycją obiektową polega z kolei na tym by zdekomponować system S o ile to możliwe w taki sposób, iż otrzymamy podsystemy o zmniejszonej liczbie obiektów, to znaczy: S = U n i=1 S i,

6 6 z 19 gdzie: S i = <X i, A, V, ρ i >, X i є X i U i X i = X, ρ i = ρ Xi W tak zdekomponowanym systemie stosujemy MLI w podsystemach Gdzie ta oszczędność? Otóż listy inwersyjne tworzone w podsystemach są na ogół znacznie krótsze, co przyspiesza wyszukiwanie i zmniejsza zajętość pamięci w obrębie podsystemu Odpowiedź na pytanie t jest tworzona w systemie S po wyszukaniu odpowiedzi z podsystemów Dzięki temu często wyszukiwania prowadzone są niezależnie, w oddzielnych fizycznie podsystemach (przetwarzanie rozproszone) Wzór na redundancję w tym przypadku przyjmie postać: R = ( r i=1 #α(d i ) Xi N)/N Taka modyfikacja stosowana jest przede wszystkim dla systemów wyszukiwania o dużych zbiorach obiektów, które opisane są takimi samymi atrybutami Wtedy wygodniej jest podzielić ten zbiór obiektów na podzbiory MLI z dekompozycją atrybutową wprowadzamy w przypadku, gdy pytania do systemu specyfikują tylko wartości pewnego podzbioru atrybutów Wówczas system S = <X, A, V, ρ> dzielimy na podsystemy S i tak, że: S = U i S i, gdzie: S i = <X, A i, V i, ρ i >, A i є A i U i A i = A, V i є V, ρ i = ρ X Ai W takim przypadku z każdym podsystemem S i systemu S związany jest zbiór deskryptorów D i Listy inwersyjne tworzymy oddzielnie dla każdego podsystemu S i Odpowiedź znajdujemy w systemie S i jako odpowiedź przybliżoną (σ(t i ) = (α(d 1 ) n α(d 2 ) nn α(d k )) Di ) Dokładną odpowiedź można w zawężonym zbiorze obiektów znaleźć metodą przeglądu zupełnego Redundancja R przyjmuje dla tej modyfikacji wartość określoną wzorem: R = ( r i=1 #α(d i ) Di N)/N Jak widać zmniejsza to jedynie zbiór list w podsystemach Tego typu modyfikacja jest stosowana przede wszystkim wtedy, gdy napływające do systemu pytania dotyczą tylko pewnych atrybutów Wtedy zgodnie z typem pytań tworzymy podsystemy o takim samym zbiorze obiektów i mniejszym zbiorze atrybutów Modyfikacje czasowe Polegają na ustawieniu kolejności całych list inwersyjnych w celu skrócenia czasu wyszukiwania dla pytań szczegółowych uporządkowanie kolejności list inwersyjnych według długości (od krótkich do długich) - umożliwia efektywne stosowanie wyszukiwanie poprzez generację listy, a następnie sprawdzania wyszukanych obiektów z odpowiedzi przybliżonej Przypomina to wyszukiwanie szczegółowe dla metody łańcuchowej uporządkowanie kolejności list inwersyjnych np alfabetyczne, umożliwia szybsze wyszukanie samej listy inwersyjnej W wyszukiwaniu listy można stosować np metodę podziału połówkowego uporządkowanie kolejności list inwersyjnych względem częstości pytania o deskryptory

7 7 z 19 Trochę praktyki dla utrwalenia wiedzy, czyli trening czyni mistrza Przypomnienie kartoteki wtórnej, czyli jak to było X = {P54C, P55C, Covington, Mendocino, Coppermine, Klamath, Deschutes, Katmai, Coppermine2, Tualatin, Willamette, NorthwoodA, NorthwoodB, NorthwoodC, Prestonia, Prescott, P6, DeschutesMP, Tanner, Cascades, Foster, Gallatin, 5K86, LittleFoot, Chompers, Sharptooth, Spitfire, Morgan, Pluto, Orion, Thunderbird, Palomino, Thoroughbred, Barton, Applebred, Thorton, SledgeHammer, Newcastle, ClawHammer} jest zbiorem obiektów systemu S, w naszym przypadku każdy obiekt to jeden z rdzeni procesorów firmy Intel lub AMD A = {Proc, Obud, Ltr, Socket, L2, FSB, Clock, PrT, Tmax, Pmax, HT, MemC} stanowi zbiór atrybutów systemu S, gdzie: Proc oznacza rodzinę procesorów w jakiej świat ujrzał dany rdzeń, Obud oznacza rodzaj obudowy w jakiej ujrzeliśmy dany rdzeń, Ltr określa liczbę tranzystorów z których jest zbudowany dany rdzeń, Socket określa jakim złączem dany rdzeń komunikował się z resztą świata, L2 opisuje maksymalną ilość pamięci Cache level2 dostępnej dla danego rdzenia, FSB traktuje o maksymalnej prędkości pracy tej szyny dla danego rdzenia, Clock opisuje największy zegar osiągnięty dla danego rdzenia, PrT informuje o procesie technologicznym w jakim dany rdzeń był/jest wytwarzany, Tmax podaje największą temperaturę do jakiej dany rdzeń może się grzać, Pmax podobnie do powyższego, ale określa maksymalną pobieraną moc, HT informuje czy dany rdzeń oferuje technologię HyperThreadingu, MemC informuje czy dany rdzeń jest wyposażony w kontroler pamięci, a także jakiego typu jest ten kontroler V jest zbiorem wszystkich wartości wszystkich atrybutów, i tak: Vproc = {I, P, Pm Pro, P2, P3, P4, C, P2X, P3X, X, K5, K6, D, A, AXP, A64}, gdzie: I Inna, P Intel Pentium, Pm Intel Pentium MMX, Pro Intel Pentium Pro, P2 Intel Pentium 2, P3 Intel Pentium 3, P4 Intel Pentium 4, C Intel Celeron, P2X Intel Pentium 2 Xeon, P3X Intel Pentium 3 Xeon, X Intel Xeon DP/MP, K5 AMD K5, K6 AMD K6, D AMD Duron, A AMD Athlon, AXP AMD Athlon XP, A64 AMD Athlon 64/FX/Opteron Vobud = {S1, S2, S3, P1, P2, F, C, CM, O1, O2, O3, L, I}, gdzie: S1 SPGA, S2 SEPP, S3 SECC/SECC2, P1 PGA, P2 PPGA, F FCPGA/FCPGA2, C CPGA, CM CardModule, O1 OPGA, O2 OOI, O3 OLGA2/OLGA1, L FCLGA4, I Inna Vltr = {bmalo, malo, srednio, duzo, bduzo, tlum, wow!}, gdzie: <10mln bmało, 10-20mln malo, 20-30mln srednio, 30-40mln duzo, 40-50mln bduzo, mln tlum, >100mln wow! Vsocket = {3, 4a, 4b, 4c, 5, 6, 7a, 7b, 7c, 8, 9a, 9b, A, SA, S1, S2, I}, gdzie: 3 370, 4a 423pins, 4b 478pins, 4c 495pins, 5 socket5 (320pins), 6 603pins (INT3/INT2), 7a socket7 (321pins), 7b 775pins, 7c 754pins, 8 socket8 (387pins), 9a 940pins, 9b 939pins, A socket a (462pins), SA SlotA (SC242), S1 Slot1 (SC242), S2 Slot 2 (330pins), I Inny Vl2 = {M, S, D, O}, gdzie: M - <64KB, S KB, D KB, O - >512KB VFSB = {0, 1, 2, 3, 4, I}, gdzie: 0 <66MHz, MHz, 2 100/133MHz, 3 133/166MHz, 4 166/200MHz, I Inne Vclock = {bwolny, Wolny, Sredni, Szybki, bszybki, Hyper}, gdzie: bwolny <500MHz, Wolny MHz, Sredni MHz, Szybki MHz, bszybki MHz, Hyper >3500MHz VprT = {bstary, Stary, Sredni, Nowy, bnowy, Mikro, I}, gdzie: bstary pow350nm, Stary 350nm, Sredni 250nm, Nowy 180nm, bnowy 130nm, Mikro 90nm, I Inny Vtmax = {Lod, Chlodny, Cieply, Goracy, Parzy, Zar}, gdzie: Lod <60stC, Chlodny 60-69stC, Cieply 70-74stC, Goracy 75-79stC, Parzy 80-85stC, Zar >85stC Vpmax = {1, 2, 3, 4, 5, 6}, gdzie: 1 - <20W, W, W, W, W, 6 - >100W VHT = {1, 0}, gdzie: 1 Tak, 0 Nie VmemC = {0, 1, 2, I}, gdzie: 0 brak, 1 jednokanałowy, 2 dwukanałowy, I Inny No i ostatecznie kartoteka

8 8 z 19 X\A Proc Obud Ltr Socket L2 FSB Clock PrT Tmax Pmax HT MemC P54C P S1 bmalo 7 D 0 bwolny bstary Chlodny P55C Pm S1 bmalo 7 D 1 bwolny Stary Chlodny Covington C S2 bmalo S1 M 1 bwolny Stary Goracy Mendocino C S2 Malo S1 S 1 bwolny Sredni Parzy Coppermine C F Malo 3 S 1 Sredni Nowy Zar Klamath P2 S3 bduzo S1 D 1 bwolny Stary Cieply Deschutes P2 S3 bduzo S1 D 1 bwolny Sredni Zar Katmai P3 S3 bduzo S1 D 2 Wolny Sredni Zar Coppermine2 P3 S3 Srednio S1 S 2 Wolny Nowy Parzy Tualatin P3 F Srednio 3 S 2 Sredni bnowy Chlodny Willamette P4 O2 bduzo 4a S 1 Sredni Nowy Cieply NorthwoodA P4 F Tlum 4b D 2 bszybki bnowy Cieply NorthwoodB P4 F Tlum 4b D 2 bszybki bnowy Cieply NorthwoodC P4 F Tlum 4b D 4 bszybki bnowy Chlodny Prestonia P4 F Wow! 4b D 4 bszybki bnowy Chlodny Prescott P4 L Wow! 7b O 4 Hyper Mikro Cieply P6 Pro C Tlum 8 O 0 bwolny Stary Parzy DeschutesMP P2X O3 Wow! S2 O 1 bwolny Sredni Cieply Tanner P3X S3 Wow! S2 O 1 Wolny Sredni Cieply Cascades P3X O3 Srednio 4c S 2 Wolny Nowy Lod Foster X P2 Tlum 6 O 1 Sredni Nowy Goracy Gallatin X P2 Wow! 6 D 1 bszybki bnowy Cieply K86 K5 P1 bmalo 5 D 0 bwolny Stary Parzy LittleFoot K6 P1 bmalo 5 D 1 bwolny Stary Chlodny Chompers K6 P1 bmalo 7a D 1 Wolny Sredni Chlodny Sharptooth K6 P1 Srednio 7a D 1 bwolny Sredni Chlodny Spitfire D C Srednio A S 1 Wolny Nowy Zar Morgan D C Srednio A S 1 Sredni Nowy Zar Pluto A CM Srednio SA D 1 Wolny Sredni Chlodny Orion A CM Srednio SA D 1 Wolny Nowy Chlodny Thunderbird A C Duzo A S 2 Sredni Nowy Zar Palomino AXP O1 Duzo A S 2 Sredni Nowy Zar Thoroughbred AXP O1 Duzo A S 3 Szybki bnowy Zar Barton AXP O1 Tlum A D 4 Szybki bnowy Parzy Applebred D O1 Srednio A M 3 Sredni bnowy Parzy Thorton AXP O1 Duzo A S 3 Szybki bnowy Zar SledgeHammer A64 O1 Wow! 9a O 4 Szybki bnowy Parzy Newcastle A64 O1 Tlum 9b O 4 Szybki bnowy Chlodny ClawHammer A64 O1 Wow! 7c O 4 Szybki bnowy Parzy Tworzymy funkcję adresującą Jak widać nasza kartoteka wtórna jest stosunkowo rozbudowana, a duża liczba obiektów o długiej nazwie może spowodować, iż redundantna MLI może zająć względnie duży obszar pamięci Aby ją zaoszczędzić w trakcie tworzenia list inwersyjnych, już teraz wprowadzamy adresy obiektów (w naszym przypadku będą to tylko indexy obiektów) do kartoteki wtórnej, oto więc nasza funkcja adresująca w postaci tabeli:

9 9 z 19 Index X\A 1 P54C 2 P55C 3 Covington 4 Mendocino 5 Coppermine 6 Klamath 7 Deschutes 8 Katmai 9 Coppermine 10 Tualatin 11 Willamette 12 NorthwoodA 13 NorthwoodB 14 NorthwoodC 15 Prestonia 16 Prescott 17 P6 18 DeschutesMP 19 Tanner 20 Cascades 21 Foster 22 Gallatin 23 5K86 24 LittleFoot 25 Chompers 26 Sharptooth 27 Spitfire 28 Morgan 29 Pluto 30 Orion 31 Thunderbird 32 Palomino 33 Thoroughbred 34 Barton 35 Applebred 36 Thorton 37 SledgeHamme 38 Newcastle 39 ClawHammer Tworzenie kartoteki wyszukiwawczej, czyli jeszcze raz to samo Kartoteka w metodzie klasycznej α(proc,p1)={1} α(proc,pm)={2} α(proc,c)={3,4,5} α(proc,p2)={6,7} α(proc,p3)={8,9,10} α(proc,p4)={11,12,13,14,15,16} α(proc,pro)={17} α(proc,p2x)={18} α(proc,p3x)={19,20}

10 10 z 19 α(proc,x)={21,22} α(proc,k5)={23} α(proc,k6)={24,25,26} α(proc,d)={27,28,35} α(proc,a)={29,30,31} α(proc,axp)={32,33,34,36} α(proc,a64)={37,38,39} α(proc,i)={ø} α(obud,s1)={1,2} α(obud,s2)={3,4} α(obud,f)={5,9,11,12,13} α(obud,s3)={6,7,8,19} α(obud,o2)={10} α(obud,l)={14} α(obud,c)={15} α(obud,o3)={18,20} α(obud,p2)={21,22} α(obud,p1)={23,24,25,26} α(obud,c)={27,28,31} α(obud,cm)={29,30} α(obud,o1)={32,33,34,35,36,37,38,39} α(obud,i)={ø} α(ltr,bmało)={1,2,3,23,24,25} α(ltr,mało)={4,5} α(ltr,srednio)={9,10,20,26,27,28,29,30,35} α(ltr,duzo)={31,32,33,36} α(ltr,bduzo)={6,7,8,11} α(ltr,tlum)={12,13,14,17,21,34,38} α(ltr,wow!)={15,16,18,19,22,37,39} α(socket,7)={1,2} α(socket,s1)={3,4,6,7,8,9,} α(socket,3)={5,10} α(socket,4a)={11} α(socket,4b)={12,13,14,15} α(socket,7b)={16} α(socket,8)={17} α(socket,s2)={18,19} α(socket,4c)={20} α(socket,6)={21,22} α(socket,5)={23,24} α(socket,7a)={25,26} α(socket,a)={27,28,31,32,33,34,35,36} α(socket,sa)={29,30} α(socket,9a)={37} α(socket,9b)={38} α(socket,7c)={39} α(socket,i)={ø} α(l2,d)={1,2,6,7,8,12,13,14,15,22,23,24,25,26,29,30,34} α(l2,m)={3,35} α(l2,s)={4,5,9,10,11,20,27,28,31,32,33,36} α(l2,o)={16,17,18,19,21,37,38,39} α(fsb,0)={1,17,23} α(fsb,1)={2,3,4,5,6,7,11,18,19,21,22,24,25,26,27,28,29,30} α(fsb,2)={8,9,10,12,13,20,31,32} α(fsb,3)={33,35,36} α(fsb,4)={14,15,16,34,37,38,39} α(fsb,i)={ø} α(clock,bwolny)={1,2,3,4,6,7,17,18,23,24,26} α(clock,wolny)={8,9,19,20,25,27,29,30} α(clock,sredni)={5,10,11,21,28,31,32,35} α(clock,szybki)={33,34,36,37,38,39}

11 11 z 19 α(clock,bszybki)={12,13,14,15,22} α(clock,hyper)={16} α(prt,bstary)={1} α(prt,stary)={2,3,6,17,23,24} α(prt,sredni)={4,7,8,18,19,25,26,29} α(prt,nowy)={5,9,11,20,21,27,28,30,31,32} α(prt,bnowy)={10,12,13,14,15,22,33,34,35,36,37,38,39} α(prt,mikro)={16} α(prt,i)={ø} α(tmax,lod)={20} α(tmax,chlodny)={1,2,10,14,15,24,25,26,29,30,38} α(tmax,cieply)={6,11,12,13,16,18,19,22} α(tmax,goracy)={3,21} α(tmax,parzy)={4,9,17,23,34,35,37,39} α(tmax,zar)={5,7,8,27,28,31,32,33,36} α(pmax,1)={1,2,3,23} α(pmax,2)={4,5,7,8,9,10,24,26} α(pmax,3)={6,17,18,19,20,27,28,29,35} α(pmax,4)={11,12,21,30,31,32,33,34,36} α(pmax,5)={13,14,22,37,38,39} α(pmax,6)={15,16} α(ht,0)={1,2,3,4,5,6,7,8,9,10,11,12,17,18,19,20,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39} α(ht,1)={13,14,15,16,21,22} α(memc,0)= {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36} α(memc,1)={38,39} α(memc,2)={37} α(memc,i)={ø} Metoda klasyczna przykłady W części zatytułowanej Klasycznie biorąc się z bykiem za rogi już omówiliśmy podstawy teoretyczne operacji w systemiewyszukiwania informacji opartym na klasycznej MLI, zatem nie będziemy już dublować naszych słów, zainteresowanych natomiast odsyłamy do odpowiedniego fragmentu tego tekstu W przypadku aktualizacji, dla oszczędzenia miejsca, będziemy podawać tylko te fragmenty kartoteki wyszukiwawczej, które się zmienią Przykład 1 wyszukiwanie określonych obiektów Mamy za zadanie wyszukać te jądra procesorów, które nie dysponują wbudowanym kontrolerem pamięci i zegarem o maksymalnej prędkości lężącej gdzieś w przedziale (25GHz-35GHz)lub procesorów oferujących funkcję przetwarzania wielopotokowego realizowanego sprzętowo, tj Oferującego HyperThreading Zadajemy więc do naszej bazy danych następujące pytanie: t = (MemC,0) (Clock,bszybki)+(HT,1) t = t 1 + t 2 Jak widać nasz term złożony jest z 2 termów składowych, zatem szukając odpowiedzi skorzystamy ze wzoru: σ(t) = σ(t 1 ) u σ(t 2 ) tu jednak, trzeba zauważyć, że t 1 jest iloczynem deskryptorowym, więc: σ(t 1 ) = α(d 1 ) n α(d 2 ), gdzie d 1 =(MemC,0), a d 2 =(Clock,bszybki) Term składowy t 2 składa się tylko z jednego deskryptora, więc: σ(t 2 ) = α(d 3 ) Mając juz przygotowane i rozłożone na czynniki pierwsze pytanie przystępujemy do analizy list: α(d 1 ) = α(memc,0) = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36} α(d 2 ) = α(clock,bszybki)={12,13,14,15,22}

12 12 z 19 α(d 3 ) = α(ht,1)={13,14,15,16,21,22} otrzymując kolejno: σ(t 1 ) = {12,13,14,15,22} σ(t 2 ) = {13,14,15,16,21,22} Mając wyznaczone odpowiedzi na termy składowe przystępujemy do wyznaczenia odpowiedzi całkowitej: σ(t) = σ(t 1 ) u σ(t 2 ) = {12,13,14,15,16,21,22} Jak widać taka odpowiedź mogłaby być dla użytkownika w pewnym stopniu nieczytelna, dlatego korzystając z tablicy funkcji adresowej uzyskujemy ostatecznie, że: σ(t) = {NorthwoodA, NorthwoodB, NorthwoodC, Prestonia, Prescott, Foster, Gallatin} która to odpowiedź pokrywa się z tym samym przykładem ze sprawozdania poświęconego MLP Przykład 2 wstawianie obiektu Niech dane nam będzie zadanie wstawienia informacji o procesorze Nocona Mamy dane po zinterpretowaniu tekstu normalnego takie informacje o jądrze 64bitowym Intela przedstawione w formie adekwatnej do naszej kartoteki wtórnej: 37 SledgeHammer A64 O1 Wow! 9a O 4 Szybki bnowy Parzy Newcastle A64 O1 Tlum 9b O 4 Szybki bnowy Chlodny ClawHammer A64 O1 Wow! 7c O 4 Szybki bnowy Parzy Nocoma X L Wow! I O 4 Hyper Mikro Chlodny To samo zapisane w kartotece wyszukiwawczej MLP by wyglądało tak: tnocoma = (Proc,X) (Obud,L) (Ltr,wow!) (Socket,I) (L2,O) (FSB,4) (Clock,Hyper) (PrT,Mikro) (Tmax,chlodny) (Pmax,5) (HT,1) (MemC,0) Aby wstawić taki obiekt musimy tak zmodyfikować wszystkie listy inwersyjne opisujące deskryptory występujące w opisie nowego obiektu by wskazywały na nowy obiekt: α(proc,x)={21,22,40} α(obud,l)={14,40} α(ltr,wow!)={15,16,18,19,22,37,39,40} α(socket,i)={40} α(l2,o)={16,17,18,19,21,37,38,39,40} α(fsb,4)={14,15,16,34,37,38,39,40} α(clock,hyper)={16,40} α(prt,mikro)={16,40} α(tmax,chlodny)={1,2,10,14,15,24,25,26,29,30,38,40} α(pmax,5)={13,14,22,37,38,39,40} α(ht,1)={13,14,15,16,21,22,40} α(memc,0)= {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,40} W ten sposób dodaliśmy ten obiekt Jądro Nocoma jest już w naszej bazie Przykład 3 aktualizacja opisu obiektu Niech dane nam będzie zadanie modyfikacji opisu dopiero co wprowadzonego opisu Nocomy, tak by teraz opis wyglądał jak w kartotece wtórnej: 37 SledgeHammer A64 O1 Wow! 9a O 4 Szybki bnowy Parzy Newcastle A64 O1 Tlum 9b O 4 Szybki bnowy Chlodny ClawHammer A64 O1 Wow! 7c O 4 Szybki bnowy Parzy Nocoma X I Wow! I O 4 Hyper Mikro Chlodny Aby to zrobić musimy usunąć wskaźnik do obiektu z jednej listy i wstawić go do innej A zatem: α(obud,l)={14} α(obud,i)={40}

13 13 z 19 Dokonaliśmy zatem zmiany opisu Przykład 4 usuwanie obiektu Aby usunąć obiekt, poza usunięciem nazwy i opisu, a zatem i wszystkich odnośników, należy zawsze sprawdzić czy taka zmiana nie zachwieje funkcją adresacji, przez co musielibyśmy dla wszystkich zmian ewentualnych adresu modyfikować opisy i listy obiektów dotknietych fluktuacją W naszym przypadku usuwamy jednakże obiekt ostatni, więc nie będziemy musieli męczyć się z aktualizacją opisów innych obiektów Przejdźmy więc do usuwania: α(proc,x)={21,22} α(obud,i)={ø} α(ltr,wow!)={15,16,18,19,22,37,39} α(socket,i)={ø} α(l2,o)={16,17,18,19,21,37,38,39} α(fsb,4)={14,15,16,34,37,38,39} α(clock,hyper)={16} α(prt,mikro)={16} α(tmax,chlodny)={1,2,10,14,15,24,25,26,29,30,38} α(pmax,5)={13,14,22,37,38,39} α(ht,1)={13,14,15,16,21,22} α(memc,0)= {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36} Kartoteka w MLI ze zmniejszonym zbiorem list inwersyjnych Zakładamy, że do naszego systemu funkcjonującego 24 godziny na dobę, 7 dni w tygodniu od miesiąca wpłynęło wystarczająco dużo pytań, stosunkowo zróżnicowanych, że możemy wykorzystać tę metodę dla zoptymalizowania procesu Oto bowiem jak się przedstawia lista najczęściej pojawiających się deskryptorów w pytaniach kierowanych do naszego SWI: α(clock,bszybki) 75% α(l2,o) 10% α(fsb,4) 9% α(prt,bnowy) 3% Jak widać, ponieważ pozostałe deskryptory nie były do tej pory wykorzystywane przy zadawaniu pytań do systemu, to stwierdzamy, że pytania o inny deskryptor jak te wymienione powyzej i w dalszym funkcjonowaniu systemu będą grupą marginalną Aktualizacje przedstawimy podobnie do aktualizacji w klasycznym podejściu do MLI, tj Pokażemy tylko te listy inwersyjne, które w wyniku aktualizacji zmienią się Przejdźmy więc do opisu dokładniejszego tej metody, bowiem w części teoretycznej podaliśmy tylko krótkie wprowadzenia do najczęściej stosowanych metod Trochę teorii nie zawadzi, czyli od teoretyka do praktyka W tej modyfikacji tworzymy listy inwersyjne α(d i ), gdzie d i є D' i U i d i = D' Pytanie do systemu zadajemy w postaci termu t Zakładamy, ze tak jak w klasycznej metodzie list inwersyjnych term t ma postać sumy termów składowych: t = t 1 ++ t m Odpowiedź na taki term, tj σ(t) jest sumą odpowiedzi na termy składowe Wyszukiwanie odpowiedzi na term składowy z kolei odbywa się zależnie od tego jak wygląda ten term t i : Przypadek pierwszy wszystkie deskrytpory pytania d i є D' W tym przypadku wyszukiwanie odpowiedzi odbywa się tak jak w klasycznej metodzie list inwersyjnych, tj σ(t i ) = α(d 1 ) n α(d 2 ) nn α(d m ), gdzie t i = d 1 d 2 d m, gdzie odpowiednio d j є D' i 1 j m a m liczba deskryptorów pytania t i Przypadek drugi nie wszystkie deskryptory pytania t i należą do zbioru D' W tym przypadku znajdujemy najpierw odpowiedź przybliżoną jako zbiór X D' następującej postaci: X D' = j є J α(d j ), gdzie J = {j: d j є D', d j є t i } Oczywiście X ti є X D' Zatem dla deskryptorów ze zbioru D' znajdujemy zbiór obiektów zgodnie z metodą

14 14 z 19 list inwersyjnych Otrzymany zbiór obiektów przglądamy następnie metodą list prostych, aby znaleźć adresy obiektów, w których opisie są pozostałe deskryptory pytania, co opisuje poniższy wzór: σ(t i ) =X ti = {x є X D', ρx(ai) = vi, (ai, vi) = di є t i oraz di D ' } Przypadek trzeci wszystkie deskryptory pytania ti D ' W tym przypadku nie pozostaje nam nic innego jak znaleźć odpowiedź metodą przeglądu zupełnego Właściwa kartoteka, czyli widać zmniejszenie redundancji Uzbrojeni w młodzieńczy zapał oraz tonaż wiedzy teoretycznej budujemy kartotekę wyszukiwawczą zmodyfikowanej MLI α(clock,bszybki)={12,13,14,15,22} α(l2,o)={16,17,18,19,21,37,38,39} α(fsb,4)={14,15,16,34,37,38,39} α(prt,bnowy)={10,12,13,14,15,22,33,34,35,36,37,38,39} Jak widać tak zredukowana kartoteka, dla D' = {(Clock,bszybki),(L2,O),(FSB,4),(PrT,bnowy)} nie dość że zmniejszy redundancję to jeszcze, co było do przewidzenia, znacznie poprawi parametr z którego słynie MLI (oczywiście wciąż mówimy o pewnej klasie pytań to jest przypadek pierwszy na pewno tu pasuje, drugi natomiast zależnie od czasu jaki będzie potrzebny na przegląd zupełny zawężonego podzbioru N lub X) Dodatkowo zastosowaliśmy tu dodatkową metodę czasową (3 z wymienionych w części teoretycznej), która dodatkowo powinna skrócić czas wyszukiwania odpowiedzi MLI ze zmniejszonym zbiorem list inwersyjnych przykłady Przejdźmy więc do podstawowych procesów/czynności jakie możemy na kartotece wyszukiwawczej w tej modyfikacji wykonać Przykład 1 wyszukanie obiektu Pomijamy prymitywny przypadek, gdy pytanie zawiera tylko i wyłącznie deskryptory, względem których dokonaliśmy modyfikacji, bowiem wtedy nie byłoby to niczym interesującym i nie wniosło by do tematu żadnej informacji Niech dane nam będzie zadanie znalezienia tych jąder procesorowych, które oferują maksymalny zegar leżący gdzieś w przedziale (25GHz-35GHz), z ogromnym cachem L2 (tj powyżej 512KB) i szyną systemową 200MHz lub procesory produkowane w procesie technologicznym 130nm debiutujące w ramach rodziny Inetl Pentium4 Mamy więc: t = (Clock,bszybki) (L2,O) (FSB,4) + (PrT,bnowy) (Proc,P4) czyli t = t 1 + t 2 po wydzieleniu termów składowych pytania Zatem bazując na teorii mamy: σ(t 1 ) = α(d 1 ) n α(d 2 ) n α(d 3 ) σ(t 2 ) = α(d 4 ) n α(d 5 ) Jak widać odpowiedź na term składowy t 1, tj σ(t 1 ), zostanie wyznaczona w sposób klasyczny w ramach zawężonej kartoteki wyszukiwawczej, bo wszytkie deskryptory d i termu składowego t 1 należą do D' Otrzymujemy więc, że: σ(t 1) = α(d 1) n α(d 2) n α(d 3) = {12,13,14,15,22} n {16,17,18,19,21,37,38,39} n {14,15,16,34,37,38,39} = Ø W drugim termie składowym sytuacja nieco się komplikuje, bowiem o ile deskrytpor d 4 =(PrT,bnowy) jest jednym z wyodrębnionych deskryptorów, względem których przeprowadzony był proces optymalizacji, o tyle drugi deskryptor (d 5 = (Proc,P4)) już do tego wyodrębnionego zbioru D' nie należy Mamy zatem przypadek drugi opisany w podczęści Trochę teorii nie zawadzi Postępując zgodnie z podaną tam techniką wyznaczamy zbiór przybliżony odpowiedzi generując listę α(d 4 ): N ti D' = α(d 4 ) = α(prt,bnowy) = {10,12,13,14,15,22,33,34,35,36,37,38,39} następnie korzystając z funkcji adresującej uzyskujemy obiekty będące przybliżoną odpowiedzią na nasze pytanie:

15 15 z 19 X ti D' = X D' = {Tualatin, NothwoodA, NorthwoodB, NorthwoodC, Prestonia, Gallatin, Palomino, Thoroughbred, Barton, Applebred, Thorton, SledgeHammer, Newcastle, ClawHammer} Dla takiego zbioru, kontynuując algorytm stosujemy metodę list prostych, czyli bazując na opisach: ttualatin = (Proc,P3) (Obud,O2) (Ltr,srednio) (Socket,3) (L2,S) (FSB,1) (Clock,sredni) (PrT,bnowy) (Tmax,chlodny) (Pmax,2) (HT,0) (MemC,0) tnorthwooda = (Proc,P4) (Obud,F) (Ltr,tlum) (Socket,4b) (L2,D) (FSB,2) (Clock,bszybki) (PrT,bnowy) (Tmax,cieply) (Pmax,4) (HT,0) (MemC,0) tnorthwoodb = (Proc,P4) (Obud,F) (Ltr,tlum) (Socket,4b) (L2,D) (FSB,4) (Clock,bszybki) (PrT,bnowy) (Tmax,cieply) (Pmax,5) (HT,1) (MemC,0) tnorthwoodc = (Proc,P4) (Obud,F) (Ltr,tlum) (Socket,4b) (L2,D) (FSB,4) (Clock,bszybki) (PrT,bnowy) (Tmax,chlodny) (Pmax,5) (HT,1) (MemC,0) tprestonia = (Proc,P4) (Obud,L) (Ltr,wow!) (Socket,4b) (L2,D) (FSB,4) (Clock,bszybki) (PrT,bnowy) (Tmax,chlodny) (Pmax,6) (HT,1) (MemC,0) tgallatin = (Proc,X) (Obud,P1) (Ltr,wow!) (Socket,6) (L2,D) (FSB,0) (Clock,bszybki) (PrT,bnowy) (Tmax,cieply) (Pmax,5) (HT,1) (MemC,0) tpalomino = (Proc,AXP) (Obud,O1) (Ltr,duzo) (Socket,A) (L2,S) (FSB,3) (Clock,sredni) (PrT,nowy) (Tmax,zar) (Pmax,4) (HT,0) (MemC,0) tthoroughbred = (Proc,AXP) (Obud,O1) (Ltr,duzo) (Socket,A) (L2,S) (FSB,4) (Clock,szybki) (PrT,bnowy) (Tmax,zar) (Pmax,4) (HT,0) (MemC,0) tbarton = (Proc,AXP) (Obud,O1) (Ltr,tlum) (Socket,A) (L2,D) (FSB,3) (Clock,szybki) (PrT,bnowy) (Tmax,parzy) (Pmax,4) (HT,0) (MemC,0) tapplebred = (Proc,D) (Obud,O1) (Ltr,srednio) (Socket,A) (L2,M) (FSB,3) (Clock,sredni) (PrT,bnowy) (Tmax,parzy) (Pmax,3) (HT,0) (MemC,0) tthorton = (Proc,AXP) (Obud,O1) (Ltr,duzo) (Socket,A) (L2,S) (FSB,) (Clock,szybki) (PrT,bnowy) (Tmax,zar) (Pmax,4) (HT,0) (MemC,0) tsledgehammer = (Proc,A64) (Obud,O1) (Ltr,wow!) (Socket,9a) (L2,O) (FSB,)4 (Clock,szybki) (PrT,bnowy) (Tmax,parzy) (Pmax,5) (HT,0) (MemC,2) tnewcastle = (Proc,A64) (Obud,O1) (Ltr,tlum) (Socket,9b) (L2,O) (FSB,4) (Clock,szybki) (PrT,bnowy) (Tmax,chlodny) (Pmax,5) (HT,0) (MemC,1) tclawhammer = (Proc,A64) (Obud,O1) (Ltr,wow!) (Socket,7c) (L2,O) (FSB,4) (Clock,szybki) (PrT,bnowy) (Tmax,parzy) (Pmax,5) (HT,0) (MemC,1) Przeprowadzamy przeszukiwanie: σ(d 5 ) = σ((proc, P4)) dla odnalezienia odpowiedzi szczegółowej: t 2 ttualatin nie bo d 5! ttualatin t 2 tnorthwooda tak bo d 5 tnorthwooda t 2 tnorthwoodb tak bo d 5 tnorthwoodb t 2 tnorthwoodc tak bo d 5 tnorthwoodc t 2 tprestonia tak bo d 5 tprestonia t 2 tgallatin nie bo d 5! tgallatin t 2 tpalomino nie bo d 5! tpalomino t 2 tthoroughbred nie bo d 5! tthoroughbred t 2 tbarton nie bo d 5! tbarton t 2 tapplebred nie bo d 5! tapplebred t 2 tthorton nie bo d 5! tthorton t 2 tsledgehammer nie bo d 5! tsledgehammer t 2 tnewcastle nie bo d 5! tnewcastle t 2 tclawhammer nie bo d 5! tclawhammer Bez problemu więc uzyskaliśmy, że σ(t 2 ) = {NorthwoodA, NorthwoodB, NorthwoodC, Prestonia} = {12,13,14,15}

16 16 z 19 Udzielamy więc odpowiedź całkowitą: σ(t) = σ t1 σ t2 = Ø {12,13,14,15 } = {12,13,14,15} Ponownie korzystając z funkcji adresowej otrzymujemy ostateczny wynik czytelny dla użytkownika: σ(t) = {NorthwoodA, NorthwoodB, NorthwoodC, Prestonia} Przykład 2 wstawianie nowego obiektu Niech dane nam będzie zadanie wstawienia informacji o procesorze Nocona Mamy dane po zinterpretowaniu tekstu normalnego takie informacje o jądrze 64bitowym Intela architekturalnie zgodnym wstecznie przedstawione w formie adekwatnej do naszej kartoteki wtórnej: 37 SledgeHammer A64 O1 Wow! 9a O 4 Szybki bnowy Parzy Newcastle A64 O1 Tlum 9b O 4 Szybki bnowy Chlodny ClawHammer A64 O1 Wow! 7c O 4 Szybki bnowy Parzy Nocoma X L Wow! I O 4 Hyper Mikro Chlodny To samo zapisane w kartotece wyszukiwawczej MLP by wyglądało tak: tnocoma = (Proc,X) (Obud,L) (Ltr,wow!) (Socket,I) (L2,O) (FSB,4) (Clock,Hyper) (PrT,Mikro) (Tmax,chlodny) (Pmax,5) (HT,1) (MemC,0) Aby wstawić taki obiekt musimy tak zmodyfikować wszystkie listy inwersyjne opisujące deskryptory występujące w opisie nowego obiektu by wskazywały na nowy obiekt Dodatkowo w przypadku gdy w kartotece wyszukiwawczej dla metody klasycznej tego obiektu nie ma musimy go tam wstawić, po czym wygenerować na nowo kartotekę wyszukiwawczą dla MLI ze zmniejszonym zbiorem list inwersyjnych Przystępujemy do aktualizacji klasycznej kartoteki wyszukiwawczej: α(proc,x)={21,22,40} α(obud,l)={14,40} α(ltr,wow!)={15,16,18,19,22,37,39,40} α(socket,i)={40} α(l2,o)={16,17,18,19,21,37,38,39,40} α(fsb,4)={14,15,16,34,37,38,39,40} α(clock,hyper)={16,40} α(prt,mikro)={16,40} α(tmax,chlodny)={1,2,10,14,15,24,25,26,29,30,38,40} α(pmax,5)={13,14,22,37,38,39,40} α(ht,1)={13,14,15,16,21,22,40} α(memc,0)= {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,40} W ten sposób dodaliśmy ten obiekt Jądro Nocoma jest już w naszej bazie Pozostaje tylko zmodyfikowanie/aktualizacja kartoteki wyszukiwawczej w modyfikacji MLI: α(clock,bszybki)={12,13,14,15,22} α(l2,o)={16,17,18,19,21,37,38,39,40} α(fsb,4)={14,15,16,34,37,38,39,40} α(prt,bnowy)={10,12,13,14,15,22,33,34,35,36,37,38,39} Ot i cała robota skończona! Przykład 3 aktualizacja opisu obiektu Niech dane nam będzie zadanie modyfikacji opisu dopiero co wprowadzonego opisu Nocomy, tak by teraz opis wyglądał jak w kartotece wtórnej:

17 17 z SledgeHammer A64 O1 Wow! 9a O 4 Szybki bnowy Parzy Newcastle A64 O1 Tlum 9b O 4 Szybki bnowy Chlodny ClawHammer A64 O1 Wow! 7c O 4 Szybki bnowy Parzy Nocoma X I Wow! I O 4 Hyper Mikro Chlodny Aby to zrobić musimy usunąć wskaźnik do obiektu z jednej listy i wstawić go do innej Oczywiście wszelka zmiana listy inwersyjnej wybranej do optymalizowanego zbioru D' pociąga za sobą przygotowanie nowej zmodyfikowanej kartoteki wyszukiwawczej bazującej na zaktualizowanej kartotece metody klasycznej A zatem: α(obud,l)={14} α(obud,i)={40} Dokonaliśmy zatem zmiany opisu Jak widać nie trzeba było zmieniać kartoteki wyszukiwawczej w zmodyfikowanej MLI Załóżmy jednak, ze należy przeprowadzić inną aktualizcję, bo użytkownik pomylił się co do najszybszego zegara oferowanego przez jądro Nocoma, tzn Niech teraz kartoteka wtórna zyska takie oblicze: 37 SledgeHammer A64 O1 Wow! 9a O 4 Szybki bnowy Parzy Newcastle A64 O1 Tlum 9b O 4 Szybki bnowy Chlodny ClawHammer A64 O1 Wow! 7c O 4 Szybki bnowy Parzy Nocoma X I Wow! I O 4 bszybki Mikro Chlodny Jak widać taka aktualizacja ma na celu zmianę list inwersyjnych α(clock,bszybki) i α(clock,hyper): α(clock,bszybki)= {12,13,14,15,22, 40} α(clock,hyper)= {16} a co za tym idzie modyfikujemy również kartotekę wyszukiwawczą w MLI ze zmniejszonym zbiorem list inwersyjnych Tak więc nasz nowa kartoteka wyszukiwawcza przyjmuje taką postać: α(clock,bszybki)={12,13,14,15,22, 40} α(l2,o)={16,17,18,19,21,37,38,39,40} α(fsb,4)={14,15,16,34,37,38,39,40} α(prt,bnowy)={10,12,13,14,15,22,33,34,35,36,37,38,39} Przykład 4 usuwanie obiektu Aby usunąć obiekt, poza usunięciem jego nazwy i opisu, a zatem i wszystkich odnośników w kartotece, należy zawsze sprawdzić czy taka zmiana nie zachwieje funkcją adresacji, przez co musielibyśmy dla wszystkich zmian/fluktuacji adresów innych obiektów modyfikować opisy i listy obiektów dotknietych tą zmianą W naszym przypadku usuwamy jednakże obiekt ostatni (dopiero co zaktualizowany procesor Intela Nocomę), więc nie będziemy musieli męczyć się z aktualizacją opisów innych obiektów Przejdźmy więc do usuwania usuwamy dane z kartoteki klasycznej metody: α(proc,x)={21,22} α(obud,i)={ø} α(ltr,wow!)={15,16,18,19,22,37,39} α(socket,i)={ø} α(l2,o)={16,17,18,19,21,37,38,39} α(fsb,4)={14,15,16,34,37,38,39} α(clock,bszybki)={12,13,14,15,22} α(prt,mikro)={16} α(tmax,chlodny)={1,2,10,14,15,24,25,26,29,30,38} α(pmax,5)={13,14,22,37,38,39} α(ht,1)={13,14,15,16,21,22} α(memc,0)= {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36} Teraz przechodzimy do finalnej części procesu usuwania, czyli do aktualizacji kartoteki zmodyfikowanej: α(clock,bszybki)={12,13,14,15,22} α(l2,o)={16,17,18,19,21,37,38,39} α(fsb,4)={14,15,16,34,37,38,39}

18 18 z 19 α(prt,bnowy)={10,12,13,14,15,22,33,34,35,36,37,38,39} W ten oto sposób usunęliśmy obiekt Nocoma, a także zaktualizowaliśmy wszystkie listy odnoszące się do usuniętego obiektu Proces istotnie zakończony Parametry MLI, czyli króciutkie podsumowanie Struktura bazy danych Struktura w tej metoszie jest na pewno bardziej złożona aniżeli jej odpowiednik w metodzie list prostych Bierze się to stąd, iż poza pamiętaniem opisów obiektów istnieje konieczność pamiętania w kartotece wyszukiwawczej wysoce redundantnego systemu list inwersyjnych utworzonych dla deskryptorów tego systemu Dodatkowo, dla obiektów o dużych nazwach, bądź występujących w bardzo dużych systemach, dla ułatwienia i przyspieszenia czynności opartych na kartotece wyszukiwawczej, i dla jej zmniejszenia, wprowadza się funkcję adresową, która również wnosi pewną redundancję i pewne skomplikowanie owej struktury Redundancja i zajętość pamięci Metoda ta wnosi dużą redundancję określaną wzorem: R = ( r i=1 #α(d i ) N)/N, gdzie r liczba deskryptorów w systemie, N liczba obiektów (lub adresów), a symbol #x oznacza moc zbioru x Pewne modyfikacje wpływają na zmniejszenie wartości r i=1 #α(d i ) w podsystemach, albowiem: 1 zmniejszają liczbę deskryptorów r, albo 2 skracają listy inwersyjne Zatem modyfikacje tej grupy zmniejszają redundancję w podsystemach przy jednoczesnym zachowaniu lub tylko niewielkim zmniejszeniu szybkości pracy systemu Inne modyfikacje zmniejszają redundancję, kosztem niepełnej informacji uzyskiwanej bezpośrednio bazując na zmodyfikowanej kartotece wyszukiwawczej Przez co są odpowiednie tylko dla określonej klasy pytań Aktualizacja bazy danych Wszelkie aktualizacje związane z liczbą obiektów pamiętanych w systemie, zmianą ich opisów, czy pełną reorganizacją są wykonywane w podobny sposób Każda aktualizacja wymaga bowiem dokonania zmian w listach inwersyjnych niezależnie od dodania czy usunięcia samego opisu obiektu w systemie W przypadku zmian w opisie natomiast, jesteśmy zmuszeni usunąć obiekt o nieaktualnym opisie, wprowadzić nowy aktualny, oraz zreorganizować i zupdate'wać odpowiednie listy inwersyjne Wprowadzenie natomiast większości modyfikacji pociąga za sobą w tym procesie całościową reorganizację bazy danych Czas wyszukiwania Czas wyszukiwania w tej metodzie jest bez wątpienia bardzo krótki W przypadku gdy pytanie jest zadane w postaci sumy deskryptorów, tj t = d 1 + d 2 + d d k odpowiedź jest niemal natychmiastowa i czas wyszukiwania τ jest nieomal równy czasowi generowania list τ g : τ = τ g, czy też jak kto woli czasowi wyszukania w kartotece wyszukiwawczej odpowiednich, uprzednio wygenerowanych list τ s i ich połączenia W przypadku gdy pytanie zadajemy w postaci termu t będącego sumą termów składowych t = t 1 ++ t m, to znaczy pytanie jest sumą pytań składowych t i = d 1 d 2 d k czas odpowiedzi na pytanie t jest dłuższy, gdyż dochodzi czas potrzebny na znalezienie części wspólnej wygenerowanych lis: τ = i (τ gi + τ pi ), gdzie: τ gi czas generowania i-tej listy, a τ pi czas porównywania i-tej listy z resztą Czas generowania zależy od pytania t i bo zależy od liczby deskryptorów w pytaniu, czas porównywania z kolei zależy od liczby deskryptorów pytania t i oraz od długości list związanych z tym pytaniem (τ p > τ g ) Modyfikacje mogą prowadzić do dodania czasu przeglądu list, zatem czas wyszukiwania będzie równy: τ' = τ + τ 0,

19 19 z 19 gdzie τ 0 czas wynikający z konieczności przeglądu zupełnego pewnych opisów obiektów z wygenerowanej listy Język wyszukiwania W przypadku tej metody mozemy zastosować rózne języki tworzenie list jest łatwe przy zadanym zbiorze deskryptorów, stąd też stosowanie prostego języka deskryptorowego jest bardzo dogodne W przypadku systemu pracującego w języku naturalnym konieczne jest natomiast wyodrębnienie zbioru deskryptorów charakterystycznych dla danej dziedziny w naszym systemie Tryb pracy Ze względu na stosunkowo czasochłonną aktualizację metoda ta używana jest raczej przy pracy wsadowej (bez konieczności bieżęcej aktualizacji) Wnioski, czyli jeszcze trochę ględzenia na koniec W odróżnieniu od innych metod wyszukiwania, metoda list inwersyjnych przy zapytaniu nie wymaga przeszukiwania całej bazy Stąd też, a także z faktu pewnego przyśpieszenia procesu wyszukiwania, można powiedzieć że jest to metoda, w której dla pewnej klasy zapytań osiągane są bardzo krótkie czasy wyszukiwania odpowiedzi Z tego też powodu jest to metoda często stosowana w sytemach wyszukiwania informacji wszelakiego typu Wadą tej metody, i to stosunkowo istotną, może być to, że na przetrzymywanie kartoteki wyszukiwawczej potrzebna jest dodatkowa pamięć Jednakże istnieją pewne modyfikacje prawie likwidujące lub silnie minimalizujące tą wadę W metodzie tej, dla każdego z deskryptorów wypisujemy kolejno adresy wszystkich obiektów zawierających dany deskryptor Dla pytań bardziej szczegółowych należy wyszukać listy inwersyjne dla każdego z deskryptorów pytania, a odpowiedź powstaje przez określenie części wspólnej tych list Sposób ten jest alternatywnym do sposobu dla list łańcuchowych dla pytań szczegółowych Z założenia w metodzie list inwersyjnych nie pamięta się długości list dla poszczególnych deskryptorów (brak tablicy adresowej), tak więc obliczanie części wspólnej może okazać się znacznie bardziej opłacalne pod względem czasowym Metody list prostych i list inwersyjnych umożliwiały uzyskiwanie bardzo szybkich odpowiedzi na pytania ogólne (np jednodeskryptorowe) Pytania bardziej szczegółowe znacznie wydłużały proces wyszukiwania Oczywiście pojęcie "długo" czy "krótko" są pojęciami względnymi W zależności od implementacji programowej względny jest również stopień zajęcia pamięci przez odnośniki, tablice adresowe (np dla list łańcuchowych), listy inwersyjne Do baz niewielkich, gdzie zakładamy, że będziemy do bazy zadawać pytania ogólne - na pewno metody podane wyżej będą wystarczające W epoce komputerów opracowano jednak szereg metod matematycznych, pozwalających na bardzo szybkie uzyskiwanie odpowiedzi na pytanie szczegółowe w bazach danych o wielu elementach Postaramy się, w ramach następnych sprawozdań, przedstawić przynajjmniej najpopularniejsze dwie z nich: metodę Chowa i metodę Luma Mamy nadzieje, ze całe nasze sprawozdanie udowodniło konieczność stosowania bardziej efektywnych algorytmów, oraz fakt iż lepszy algorytm to więcej niz lepszy komputer Kiepski algorytm potrafi zadławić nawet najnowszy superkomputer, podczas gdy znalezienie nowego sposobu wyszukiwania informacji, który byłby znacznie szybszy pozwala znacznie skrócić czasy wyszukiwania i to przy znacznie niższych kosztach Ostatecznie więc podsumowując W metodzie list inwersyjnych) czasy odpowiedzi na pytania jednodesktyptorowe są bardzo krótkie, ale to przyspieszenie wykonane jest kosztem dużej redundancji! CDN ;-)