sprawozdanie z metody list inwersyjnych

© COPYRIGHT 2004 MARCIN KARWIŃSKI & MARCIN DZIĘGIELEWSKI 

1 z 19 

SYSTEMY 

WYSZUKIWANIA 

INFORMACJI 

METODA 

LIST 

INWERSYJNYCH


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 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 

Wnioski, czyli jeszcze trochę ględzenia na koniec................................................................................................ 19


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 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 = . 

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 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 3 + ... + 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 ) u...u α(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 ) u...u σ(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 ) n...n α(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 ) u...u σ(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 z 19 

gdzie: 

S 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 = dzielimy na 

podsystemy S i tak, że: 

S = U i S i , 

gdzie: 

S 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 ) n...n α(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 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 = {b.malo, malo, srednio, duzo, b.duzo, tlum, wow!}, gdzie: 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 - 512KB. 

• VFSB = {0, 1, 2, 3, 4, I}, gdzie: 0 –


8 z 19 

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 

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 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 SledgeHammer 

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 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,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,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 z 19 

α(Clock,b.szybki)={12,13,14,15,22} 

α(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 = 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,b.szybki). 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,b.szybki)={12,13,14,15,22}


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 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 

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: 

. 

. 

. 




40 Nocoma X I 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. A zatem: 


α(Obud,I)={40}


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} 


α(Ltr,Wow!)={15,16,18,19,22,37,39} 


α(L2,O)={16,17,18,19,21,37,38,39} 

α(FSB,4)={14,15,16,34,37,38,39} 

α(Clock,Hyper)={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 α(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 ) n...n α(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 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. 


α(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 = 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,b.nowy) 

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 ) = α(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 

pytanie:


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,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: 

σ(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 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: 

. 

. 

. 




40 Nocoma X L Wow! I O 4 Hyper Mikro Chlodny 5 1 0 

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: 


α(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: 

. 

. 

.


17 z 19 




40 Nocoma X I 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,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: 

. 

. 

. 




40 Nocoma X I Wow! I O 4 b.szybki Mikro Chlodny 5 1 0 

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} 


α(Ltr,Wow!)={15,16,18,19,22,37,39} 


α(L2,O)={16,17,18,19,21,37,38,39} 

α(FSB,4)={14,15,16,34,37,38,39} 



α(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: 


α(L2,O)={16,17,18,19,21,37,38,39} 

α(FSB,4)={14,15,16,34,37,38,39}


18 z 19 

α(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 = (∑ 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 3 + ... + 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 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! 

C.D.N ;-)

sprawozdanie z metody list inwersyjnych

You also want an ePaper? Increase the reach of your titles

Delete template?

Save as template?