S S YSTEMY YSTEMY W W YSZUKIWANIA YSZUKIWANIA I I NFORMACJI NFORMACJI
M M ETODA ETODA L L IST IST I I NWERSYJNYCH NWERSYJNYCH
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 MLP...3
Redundancja w MLI – czyli jak ograniczyć zajętość pamięci...3
Gdzie to przyspieszenie?... 4
Aktualizacja nieco utrudniona...4
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ęciowe...5
Modyfikacje czasowe...6
Trochę praktyki dla utrwalenia wiedzy, czyli trening czyni mistrza...7
Przypomnienie kartoteki wtórnej, czyli jak to było...7
Tworzymy funkcję adresującą... 8
Tworzenie kartoteki wyszukiwawczej, czyli jeszcze raz to samo...9
Kartoteka w metodzie klasycznej... 9
Metoda klasyczna – przykłady...11
Przykład 1 – wyszukiwanie określonych obiektów... 11
Przykład 2 – wstawianie obiektu...12
Przykład 3 – aktualizacja opisu obiektu...12
Przykład 4 – usuwanie obiektu... 13
Kartoteka w MLI ze zmniejszonym zbiorem list inwersyjnych... 13
Trochę teorii nie zawadzi, czyli od teoretyka do praktyka...13
Właściwa kartoteka, czyli widać zmniejszenie redundancji... 14
MLI ze zmniejszonym zbiorem list inwersyjnych – przykłady... 14
Przykład 1 – wyszukanie obiektu...14
Przykład 2 – wstawianie nowego obiektu... 16
Przykład 3 – aktualizacja opisu obiektu...16
Przykład 4 – usuwanie obiektu... 17
Parametry MLI, czyli króciutkie podsumowanie...18
Struktura bazy danych...18
Redundancja i zajętość pamięci...18
Aktualizacja bazy danych... 18
Czas wyszukiwania...18
Język wyszukiwania...19
Tryb pracy... 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.
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 tx umieszczone są w dowolny sposób w pamięci komputera.
Dodatkowo zakładamy, że mamy dużą bazę, zatem obiektom x1,...,xn odpowiadają adresy n1,...,nm. Utworzyliśmy zatem pewein zbiór adresów N = {n1,...,nm} stosując funkcję adresującą μ w następujący sposób:
μ: X → N, przy czym μ(x)=μ (y) ↔ tx = ty
co należy czytać nastepująco – przypisujemy ten sam adres obiektom o takich samych opisach deskryptorowych.
Tworzymy listy inwersyjne (oznaczane przez α(di)), czyli listy adresów tych obiektów, które w swoim opisie zawierają deskryptor di (di є tx). Zapisujemy to jako:
α(di) = {n1,...,nz}, gdzie di = (ai, vi), ai є A, vi є Vai. Tworzymy tyle list inwersyjnych ile mamy deskryptorów w systemie.
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 = t1 +...+ tm.
• Termy składowe pytania mogą być pojedynczymi deskryptorami, a więc term t jest postaci:
t = d1 + d2 + d3 + ... + dk.
Opowiedź na pytanie t otrzymujemy bezpośrednio przez wygenerowanie list inwersyjnych dla deskryptorów występujących w pytaniu. Zatem:
σ(t) = α(d1) u α(d2) u...u α(dk).
• Termy składowe mają postać iloczynu deskryptorów. Odpowiedź na term t jest więc sumą odpowiedzi na termy składowe:
σ(t) = σ(t1) u σ(t2) u...u σ(tm).
Odpowiedź na trm składowy ti otrzymujemy jako przecięcie (część wspólna) list inwersyjnych związanych z deskryptorami występującymi w pytaniu ti:
σ(ti) = α(d1) n α(d2) n...n α(dk), gdzie ti = d1 ∙ d2 ∙...∙ dk.
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) = σ(t1) u σ(t2) u...u σ(tm),
przy czym σ(ti) = {x є X, μ(x)=ni oraz ni є N' = ∩j α(dj), gdzie N' є N, a dj є ti}. 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 = (∑ri=1 #α(di) – 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 = Uni=1 Si,
gdzie:
Si = <Xi, A, V, ρi>, Xi є X i Ui Xi = 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 = (∑ri=1 #α(di)|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 Si tak, że:
S = Ui Si, gdzie:
Si = <X, Ai, Vi, ρi>, Ai є A i Ui Ai = A, Vi є V,
ρi = ρ|X×Ai.
W takim przypadku z każdym podsystemem Si systemu S związany jest zbiór deskryptorów Di. Listy inwersyjne tworzymy oddzielnie dla każdego podsystemu Si. Odpowiedź znajdujemy w systemie Si
jako odpowiedź przybliżoną (σ(ti) = (α(d1) n α(d2) n...n α(dk))|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 = (∑ri=1 #α(di)|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.
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 = {b.malo, malo, srednio, duzo, b.duzo, tlum, wow!}, gdzie: <10mln b.mało, 10-20mln malo, 20-30mln srednio, 30-40mln duzo, 40-50mln b.duzo, 50-100mln 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 – 64-256KB, D – 256-512KB, O - >512KB.
• VFSB = {0, 1, 2, 3, 4, I}, gdzie: 0 – <66MHz, 1 – 66-100MHz, 2 – 100/133MHz, 3 – 133/166MHz, 4 – 166/200MHz, I – Inne.
• Vclock = {b.wolny, Wolny, Sredni, Szybki, b.szybki, Hyper}, gdzie: b.wolny <500MHz, Wolny 500-1000MHz, Sredni 1000-2000MHz, Szybki 2000-2500MHz, b.szybki 2500-3500MHz, Hyper >3500MHz.
• VprT = {b.stary, Stary, Sredni, Nowy, b.nowy, Mikro, I}, gdzie: b.stary – pow.350nm, Stary – 350nm, Sredni – 250nm, Nowy – 180nm, b.nowy – 130nm, Mikro – 90nm, I – Inny.
• Vtmax = {Lod, Chlodny, Cieply, Goracy, Parzy, Zar}, gdzie: Lod <60st.C, Chlodny 60-69st.C, Cieply 70-74st.C, Goracy 75-79st.C, Parzy 80-85st.C, Zar >85st.C.
• Vpmax = {1, 2, 3, 4, 5, 6}, gdzie: 1 - <20W, 2 – 20-39W, 3 – 40-59W, 4 – 60-79W, 5 – 80-100W, 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...
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:
X\A Proc Obud Ltr Socket L2 FSB Clock PrT Tmax Pmax HT MemC
P54C P S1 b.malo 7 D 0 b.wolny b.stary Chlodny 1 0 0
P55C Pm S1 b.malo 7 D 1 b.wolny Stary Chlodny 1 0 0
Covington C S2 b.malo S1 M 1 b.wolny Stary Goracy 1 0 0
Mendocino C S2 Malo S1 S 1 b.wolny Sredni Parzy 2 0 0
Coppermine C F Malo 3 S 1 Sredni Nowy Zar 2 0 0
Klamath P2 S3 b.duzo S1 D 1 b.wolny Stary Cieply 3 0 0
Deschutes P2 S3 b.duzo S1 D 1 b.wolny Sredni Zar 2 0 0
Katmai P3 S3 b.duzo S1 D 2 Wolny Sredni Zar 2 0 0
Coppermine2 P3 S3 Srednio S1 S 2 Wolny Nowy Parzy 2 0 0
Tualatin P3 F Srednio 3 S 2 Sredni b.nowy Chlodny 2 0 0
Willamette P4 O2 b.duzo 4a S 1 Sredni Nowy Cieply 4 0 0
NorthwoodA P4 F Tlum 4b D 2 b.szybki b.nowy Cieply 4 0 0
NorthwoodB P4 F Tlum 4b D 2 b.szybki b.nowy Cieply 5 1 0
NorthwoodC P4 F Tlum 4b D 4 b.szybki b.nowy Chlodny 5 1 0
Prestonia P4 F Wow! 4b D 4 b.szybki b.nowy Chlodny 6 1 0
Prescott P4 L Wow! 7b O 4 Hyper Mikro Cieply 6 1 0
P6 Pro C Tlum 8 O 0 b.wolny Stary Parzy 3 0 0
DeschutesMP P2X O3 Wow! S2 O 1 b.wolny Sredni Cieply 3 0 0
Tanner P3X S3 Wow! S2 O 1 Wolny Sredni Cieply 3 0 0
Cascades P3X O3 Srednio 4c S 2 Wolny Nowy Lod 3 0 0
Foster X P2 Tlum 6 O 1 Sredni Nowy Goracy 4 1 0
Gallatin X P2 Wow! 6 D 1 b.szybki b.nowy Cieply 5 1 0
5K86 K5 P1 b.malo 5 D 0 b.wolny Stary Parzy 1 0 0
LittleFoot K6 P1 b.malo 5 D 1 b.wolny Stary Chlodny 2 0 0
Chompers K6 P1 b.malo 7a D 1 Wolny Sredni Chlodny 2 0 0
Sharptooth K6 P1 Srednio 7a D 1 b.wolny Sredni Chlodny 2 0 0
Spitfire D C Srednio A S 1 Wolny Nowy Zar 3 0 0
Morgan D C Srednio A S 1 Sredni Nowy Zar 3 0 0
Pluto A CM Srednio SA D 1 Wolny Sredni Chlodny 3 0 0
Orion A CM Srednio SA D 1 Wolny Nowy Chlodny 4 0 0
Thunderbird A C Duzo A S 2 Sredni Nowy Zar 4 0 0
Palomino AXP O1 Duzo A S 2 Sredni Nowy Zar 4 0 0
Thoroughbred AXP O1 Duzo A S 3 Szybki b.nowy Zar 4 0 0
Barton AXP O1 Tlum A D 4 Szybki b.nowy Parzy 4 0 0
Applebred D O1 Srednio A M 3 Sredni b.nowy Parzy 3 0 0
Thorton AXP O1 Duzo A S 3 Szybki b.nowy Zar 4 0 0
SledgeHammer A64 O1 Wow! 9a O 4 Szybki b.nowy Parzy 5 0 2
Newcastle A64 O1 Tlum 9b O 4 Szybki b.nowy Chlodny 5 0 1
ClawHammer A64 O1 Wow! 7c O 4 Szybki b.nowy Parzy 5 0 1
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}
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 SledgeHammer 38 Newcastle 39 ClawHammer
α(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,b.mał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,b.duzo)={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,b.wolny)={1,2,3,4,6,7,17,18,23,24,26}
α(Clock,Hyper)={16}
α(PrT,b.stary)={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,b.nowy)={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 (2.5GHz-3.5GHz)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,b.szybki)+(HT,1) t = t1 + t2
Jak widać nasz term złożony jest z 2 termów składowych, zatem szukając odpowiedzi skorzystamy ze wzoru:
σ(t) = σ(t1) u σ(t2)
tu jednak, trzeba zauważyć, że t1 jest iloczynem deskryptorowym, więc:
σ(t1) = α(d1) n α(d2),
gdzie d1=(MemC,0), a d2=(Clock,b.szybki). Term składowy t2 składa się tylko z jednego deskryptora, więc:
σ(t2) = α(d3)
Mając juz przygotowane i rozłożone na czynniki pierwsze pytanie przystępujemy do analizy list:
α(d1) = α(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}
α(d2) = α(Clock,b.szybki)={12,13,14,15,22}
α(d3) = α(HT,1)={13,14,15,16,21,22}
otrzymując kolejno:
σ(t1) = {12,13,14,15,22}
σ(t2) = {13,14,15,16,21,22}.
Mając wyznaczone odpowiedzi na termy składowe przystępujemy do wyznaczenia odpowiedzi całkowitej:
σ(t) = σ(t1) u σ(t2) = {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:
. . .
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 b.nowy Parzy 5 0 2 38 Newcastle A64 O1 Tlum 9b O 4 Szybki b.nowy Chlodny 5 0 1 39 ClawHammer A64 O1 Wow! 7c O 4 Szybki b.nowy Parzy 5 0 1
40 Nocoma X L Wow! I O 4 Hyper Mikro Chlodny 5 1 0
37 SledgeHammer A64 O1 Wow! 9a O 4 Szybki b.nowy Parzy 5 0 2 38 Newcastle A64 O1 Tlum 9b O 4 Szybki b.nowy Chlodny 5 0 1 39 ClawHammer A64 O1 Wow! 7c O 4 Szybki b.nowy Parzy 5 0 1
40 Nocoma X I Wow! I O 4 Hyper Mikro Chlodny 5 1 0
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,b.szybki) – 75%
• α(L2,O) – 10%
• α(FSB,4) – 9%
• α(PrT,b.nowy) – 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 α(di), gdzie di є D' i Ui di = 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 = t1 +...+ tm.
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 ti :
• Przypadek pierwszy – wszystkie deskrytpory pytania di є D'
W tym przypadku wyszukiwanie odpowiedzi odbywa się tak jak w klasycznej metodzie list inwersyjnych, tj.
σ(ti) = α(d1) n α(d2) n...n α(dm), gdzie ti = d1 ∙ d2 ∙...∙ dm, gdzie odpowiednio dj є D' i 1≤j≤m a m – liczba deskryptorów pytania ti .
• Przypadek drugi – nie wszystkie deskryptory pytania ti należą do zbioru D'
W tym przypadku znajdujemy najpierw odpowiedź przybliżoną jako zbiór XD' następującej postaci:
XD' = ∩j є J α(dj), gdzie J = {j: dj є D', dj є ti}.
Oczywiście Xti є XD'. Zatem dla deskryptorów ze zbioru D' znajdujemy zbiór obiektów zgodnie z metodą
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:
σ(ti) =Xti = {x є XD', ρx(ai) = vi, (ai, vi) = di є ti 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,b.szybki)={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,b.nowy)={10,12,13,14,15,22,33,34,35,36,37,38,39}
Jak widać tak zredukowana kartoteka, dla D' = {(Clock,b.szybki),(L2,O),(FSB,4),(PrT,b.nowy)} 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 (2.5GHz-3.5GHz), 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,b.szybki)•(L2,O)•(FSB,4) + (PrT,b.nowy)•(Proc,P4) czyli t = t1 + t2 po wydzieleniu termów składowych pytania.
Zatem bazując na teorii mamy:
σ(t1) = α(d1) n α(d2) n α(d3) σ(t2) = α(d4) n α(d5)
Jak widać odpowiedź na term składowy t1, tj. σ(t1), zostanie wyznaczona w sposób klasyczny w ramach zawężonej kartoteki wyszukiwawczej, bo wszytkie deskryptory di termu składowego t1 należą do D'.
Otrzymujemy więc, że:
σ(t1) = α(d1) n α(d2) n α(d3) = {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 d4=(PrT,b.nowy) jest jednym z wyodrębnionych deskryptorów, względem których przeprowadzony był proces optymalizacji, o tyle drugi deskryptor (d5 = (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ę α(d4):
Nti|D' = α(d4) = α(Pr.T,b.nowy) = {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
Xti|D' = XD' = {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,b.nowy)•(Tmax,chlodny)•(Pmax,2)•(HT,0)•(MemC,0)
tNorthwoodA = (Proc,P4)•(Obud,F)•(Ltr,tlum)•(Socket,4b)•(L2,D)•(FSB,2)•
(Clock,b.szybki)•(PrT,b.nowy)•(Tmax,cieply)•(Pmax,4)•(HT,0)•(MemC,0)
tNorthwoodB = (Proc,P4)•(Obud,F)•(Ltr,tlum)•(Socket,4b)•(L2,D)•(FSB,4)•
(Clock,b.szybki)•(PrT,b.nowy)•(Tmax,cieply)•(Pmax,5)•(HT,1)•(MemC,0)
tNorthwoodC = (Proc,P4)•(Obud,F)•(Ltr,tlum)•(Socket,4b)•(L2,D)•(FSB,4)•
(Clock,b.szybki)•(PrT,b.nowy)•(Tmax,chlodny)•(Pmax,5)•(HT,1)•(MemC,0)
tPrestonia = (Proc,P4)•(Obud,L)•(Ltr,wow!)•(Socket,4b)•(L2,D)•(FSB,4)•
(Clock,b.szybki)•(PrT,b.nowy)•(Tmax,chlodny)•(Pmax,6)•(HT,1)•(MemC,0)
tGallatin = (Proc,X)•(Obud,P1)•(Ltr,wow!)•(Socket,6)•(L2,D)•(FSB,0)•(Clock,b.szybki)
•(PrT,b.nowy)•(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,b.nowy)•(Tmax,zar)•(Pmax,4)•(HT,0)•(MemC,0)
tBarton = (Proc,AXP)•(Obud,O1)•(Ltr,tlum)•(Socket,A)•(L2,D)•(FSB,3)•(Clock,szybki)•
(PrT,b.nowy)•(Tmax,parzy)•(Pmax,4)•(HT,0)•(MemC,0)
tApplebred = (Proc,D)•(Obud,O1)•(Ltr,srednio)•(Socket,A)•(L2,M)•(FSB,3)•
(Clock,sredni)•(PrT,b.nowy)•(Tmax,parzy)•(Pmax,3)•(HT,0)•(MemC,0)
tThorton = (Proc,AXP)•(Obud,O1)•(Ltr,duzo)•(Socket,A)•(L2,S)•(FSB,)•(Clock,szybki)•
(PrT,b.nowy)•(Tmax,zar)•(Pmax,4)•(HT,0)•(MemC,0)
tSledgeHammer = (Proc,A64)•(Obud,O1)•(Ltr,wow!)•(Socket,9a)•(L2,O)•(FSB,)4•
(Clock,szybki)•(PrT,b.nowy)•(Tmax,parzy)•(Pmax,5)•(HT,0)•(MemC,2)
tNewcastle = (Proc,A64)•(Obud,O1)•(Ltr,tlum)•(Socket,9b)•(L2,O)•(FSB,4)•
(Clock,szybki)•(PrT,b.nowy)•(Tmax,chlodny)•(Pmax,5)•(HT,0)•(MemC,1)
tClawHammer = (Proc,A64)•(Obud,O1)•(Ltr,wow!)•(Socket,7c)•(L2,O)•(FSB,4)•
(Clock,szybki)•(PrT,b.nowy)•(Tmax,parzy)•(Pmax,5)•(HT,0)•(MemC,1)
Przeprowadzamy przeszukiwanie:
σ(d5) = σ((Proc, P4)) dla odnalezienia odpowiedzi szczegółowej:
t2≤tTualatin nie bo d5 !≤ tTualatin t2≤tNorthwoodA tak bo d5 ≤ tNorthwoodA t2≤tNorthwoodB tak bo d5 ≤ tNorthwoodB t2≤tNorthwoodC tak bo d5 ≤ tNorthwoodC t2≤tPrestonia tak bo d5 ≤ tPrestonia t2≤tGallatin nie bo d5 !≤ tGallatin t2≤tPalomino nie bo d5 !≤ tPalomino t2≤tThoroughbred nie bo d5 !≤ tThoroughbred
t2≤tBarton nie bo d5 !≤ tBarton
t2≤tApplebred nie bo d5 !≤ tApplebred
t2≤tThorton nie bo d5 !≤ tThorton
t2≤tSledgeHammer nie bo d5 !≤ tSledgeHammer t2≤tNewcastle nie bo d5 !≤ tNewcastle t2≤tClawHammer nie bo d5 !≤ tClawHammer Bez problemu więc uzyskaliśmy, że
σ(t2) = {NorthwoodA, NorthwoodB, NorthwoodC, Prestonia} = {12,13,14,15}.
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:
. . .
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,b.szybki)={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,b.nowy)={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:
. .
37 SledgeHammer A64 O1 Wow! 9a O 4 Szybki b.nowy Parzy 5 0 2 38 Newcastle A64 O1 Tlum 9b O 4 Szybki b.nowy Chlodny 5 0 1 39 ClawHammer A64 O1 Wow! 7c O 4 Szybki b.nowy Parzy 5 0 1
40 Nocoma X L Wow! I O 4 Hyper Mikro Chlodny 5 1 0
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:
. . .
Jak widać taka aktualizacja ma na celu zmianę list inwersyjnych α(Clock,b.szybki) i α(Clock,Hyper):
α(Clock,b.szybki)= {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,b.szybki)={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,b.nowy)={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,b.szybki)={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,b.szybki)={12,13,14,15,22}
α(L2,O)={16,17,18,19,21,37,38,39}
α(FSB,4)={14,15,16,34,37,38,39}
37 SledgeHammer A64 O1 Wow! 9a O 4 Szybki b.nowy Parzy 5 0 2 38 Newcastle A64 O1 Tlum 9b O 4 Szybki b.nowy Chlodny 5 0 1 39 ClawHammer A64 O1 Wow! 7c O 4 Szybki b.nowy Parzy 5 0 1
40 Nocoma X I Wow! I O 4 Hyper Mikro Chlodny 5 1 0
37 SledgeHammer A64 O1 Wow! 9a O 4 Szybki b.nowy Parzy 5 0 2 38 Newcastle A64 O1 Tlum 9b O 4 Szybki b.nowy Chlodny 5 0 1 39 ClawHammer A64 O1 Wow! 7c O 4 Szybki b.nowy Parzy 5 0 1
40 Nocoma X I Wow! I O 4 b.szybki Mikro Chlodny 5 1 0
α(PrT,b.nowy)={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 = (∑ri=1 #α(di) – 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 ∑ri=1 #α(di) 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 = d1 + d2 + d3 + ... + dk
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 = t1 +...+ tm , to znaczy pytanie jest sumą pytań składowych ti = d1 ∙ d2 ∙...∙ dk 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 ti – bo zależy od liczby deskryptorów w pytaniu, czas porównywania z kolei zależy od liczby deskryptorów pytania ti oraz od długości list związanych z tym pytaniem (τp >
