SWI - MLI

Transkrypt

SWI - MLI

© COPYRIGHT 2004 MARCIN KARWIŃSKI & MARCIN DZIĘGIELEWSKI
SYSTEMY WYSZUKIWANIA INFORMACJI
METODA LIST INWERSYJNYCH
1 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
2 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.
3 z 19
Gdzie to przyspieszenie?
Taka budowa kartoteki powoduje dużą szybkość wyszukiwania, w przypadku, gdy mamy zapytania
składające się z pojedynczych deskryptorów, co też nietrudno wywnioskować z powyższego wywodu.
Wiadome jest, że w takich przypadkach kartoteka zbudowana z list inwersyjnych pozwala niezwykle
szybko, jak na tak prostą metodę, znaleźć odpowiedź na pytanie zadane do systemu. Jeżeli bowiem
pytamy o obiekty mające w swoim opisie określony deskryptor, to dla znalezienia odpowiedzi wystarczy
znaleźć właściwą listę inwersyjną. Obiekty podane w tej liście stanowią odpowiedź na pytanie. Ale też
zwiększenie liczby deskryptorów nie powoduje dużej komplikacji obliczeń. Jeżeli bowiem pytanie
dotyczy obiektów opisanych kilkoma deskryptorami, to aby otrzymać odpowiedź, należy znaleźć listy
inwersyjne dla wszystkich deskryptorów występujących w pytaniu. Następnie w takich wypadkach na
zbiorach odpowiedzi z pojedynczych deskryptorów wykonywana jest operacja AND lub OR. Wstawianie
do zapytań operatora logicznego NOT nie wiąże się również z większym problemem obliczeniowym.
Zatem dla znalezienia odpowiedzi na pytanie skierowane do systemu wystarczy wykonać pewne proste
operacje na listach inwersyjnych (czyli w zasadzie na zbiorach). Można zauważyć, ze odpowiedzi
uzyskujemy rzeczywiście szybko.
Aktualizacja nieco utrudniona
Ponieważ obiekty pamiętane są w wielu listach, to właśnie ta nadmiarowość danych powoduje pewne
utrudnienia dla procesu aktualizacji bazy danych w stosunku do przecież niezwykle prostego w
wykonaniu procesu aktualizacji bazy w systemie opartym na metodzie list prostych (w tym na wszystkich
modyfikacjach). Dodanie lub usunięcie elementu z bazy danych wiąże się z modyfikacją całej kartoteki
wyszukiwawczej - należy usunąć adres do tego rekordu (bądź nazwę obiektu opisywanego w danym
rekordzie) z wszystkich powiązanych z nim deskryptorów.
A gdzie ta inwersyjność?
Metoda list inwersyjnych różni się od metody list łańcuchowych i metody list prostych tym, że listy
łańcuchowe nie są umieszczone w opisach elementów, ale w osobnych listach. Na dodatek listy te nie
opisują bezpośrednio obiektów, czytaj dostęp do informacji nie biegnie od obiektu do informacji a
odwrotnie (stąd właśnie ta inwersyjność), tj. od wartości atrybutu do opisu obiektu, któremu funkcja
informacji właśnie tą wartość przypisała. Poza tym, w poprzednim przypadku listy były generowane
podczas wyszukiwania, tutaj natomiast są podane bezpośrednio.
Klasycznie biorąc się z bykiem za rogi...
Podobnie do MLP mamy zdefiniowany system wyszukiwania S, a więc zbiór obiektów X, atrybutów A,
wartości tych atrybutów V oraz funkcja informacji ρ. Oczywiście te elementy tworzą czwórkę
uporządkowaną:
S = <X, A, V, ρ>.
Zakładamy, że obiekty opisane są iloczynem odpowiednich niezaprzeczonych deskryptorów. Opisy
obiektów 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.
4 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 = 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,
5 z 19
•
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.
6 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: <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...
7 z 19
X\A
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
Proc Obud
Ltr
P
S1
b.malo
Pm
S1
b.malo
C
S2
b.malo
C
S2
Malo
C
F
Malo
P2
S3
b.duzo
P2
S3
b.duzo
P3
S3
b.duzo
P3
S3
Srednio
P3
F
Srednio
P4
O2
b.duzo
P4
F
Tlum
P4
F
Tlum
P4
F
Tlum
P4
F
Wow!
P4
L
Wow!
Pro
C
Tlum
P2X
O3
Wow!
P3X
S3
Wow!
P3X
O3
Srednio
X
P2
Tlum
X
P2
Wow!
K5
P1
b.malo
K6
P1
b.malo
K6
P1
b.malo
K6
P1
Srednio
D
C
Srednio
D
C
Srednio
A
CM Srednio
A
CM Srednio
A
C
Duzo
AXP
O1
Duzo
AXP
O1
Duzo
AXP
O1
Tlum
D
O1
Srednio
AXP
O1
Duzo
A64
O1
Wow!
A64
O1
Tlum
A64
O1
Wow!
Socket
7
7
S1
S1
3
S1
S1
S1
S1
3
4a
4b
4b
4b
4b
7b
8
S2
S2
4c
6
6
5
5
7a
7a
A
A
SA
SA
A
A
A
A
A
A
9a
9b
7c
L2 FSB
D
0
D
1
M
1
S
1
S
1
D
1
D
1
D
2
S
2
S
2
S
1
D
2
D
2
D
4
D
4
O
4
O
0
O
1
O
1
S
2
O
1
D
1
D
0
D
1
D
1
D
1
S
1
S
1
D
1
D
1
S
2
S
2
S
3
D
4
M
3
S
3
O
4
O
4
O
4
Clock
b.wolny
b.wolny
b.wolny
b.wolny
Sredni
b.wolny
b.wolny
Wolny
Wolny
Sredni
Sredni
b.szybki
b.szybki
b.szybki
b.szybki
Hyper
b.wolny
b.wolny
Wolny
Wolny
Sredni
b.szybki
b.wolny
b.wolny
Wolny
b.wolny
Wolny
Sredni
Wolny
Wolny
Sredni
Sredni
Szybki
Szybki
Sredni
Szybki
Szybki
Szybki
Szybki
PrT
b.stary
Stary
Stary
Sredni
Nowy
Stary
Sredni
Sredni
Nowy
b.nowy
Nowy
b.nowy
b.nowy
b.nowy
b.nowy
Mikro
Stary
Sredni
Sredni
Nowy
Nowy
b.nowy
Stary
Stary
Sredni
Sredni
Nowy
Nowy
Sredni
Nowy
Nowy
Nowy
b.nowy
b.nowy
b.nowy
b.nowy
b.nowy
b.nowy
b.nowy
Tmax
Chlodny
Chlodny
Goracy
Parzy
Zar
Cieply
Zar
Zar
Parzy
Chlodny
Cieply
Cieply
Cieply
Chlodny
Chlodny
Cieply
Parzy
Cieply
Cieply
Lod
Goracy
Cieply
Parzy
Chlodny
Chlodny
Chlodny
Zar
Zar
Chlodny
Chlodny
Zar
Zar
Zar
Parzy
Parzy
Zar
Parzy
Chlodny
Parzy
Pmax HT MemC
1
0
0
1
0
0
1
0
0
2
0
0
2
0
0
3
0
0
2
0
0
2
0
0
2
0
0
2
0
0
4
0
0
4
0
0
5
1
0
5
1
0
6
1
0
6
1
0
3
0
0
3
0
0
3
0
0
3
0
0
4
1
0
5
1
0
1
0
0
2
0
0
2
0
0
2
0
0
3
0
0
3
0
0
3
0
0
4
0
0
4
0
0
4
0
0
4
0
0
4
0
0
3
0
0
4
0
0
5
0
2
5
0
1
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:
8 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}
9 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}
10 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=
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}
11 z 19
α(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:
.
.
.
37
38
39
40
SledgeHammer
Newcastle
ClawHammer
Nocoma
A64
A64
A64
X
O1
O1
O1
L
Wow!
Tlum
Wow!
Wow!
9a
9b
7c
I
O
O
O
O
4
4
4
4
Szybki
Szybki
Szybki
Hyper
b.nowy
b.nowy
b.nowy
Mikro
Parzy
Chlodny
Parzy
Chlodny
5
5
5
5
0
0
0
1
2
1
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:
.
.
.
37
38
39
40
SledgeHammer
Newcastle
ClawHammer
Nocoma
A64
A64
A64
X
O1
O1
O1
I
Wow!
Tlum
Wow!
Wow!
9a
9b
7c
I
O
O
O
O
4
4
4
4
Szybki
Szybki
Szybki
Hyper
b.nowy
b.nowy
b.nowy
Mikro
Parzy
Chlodny
Parzy
Chlodny
5
5
5
5
0
0
0
1
Aby to zrobić musimy usunąć wskaźnik do obiektu z jednej listy i wstawić go do innej. A zatem:
α(Obud,L)={14}
α(Obud,I)={40}
12 z 19
2
1
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ą
13 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:
σ(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
pytanie:
14 z 19
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
=
(Clock,b.szybki)•(PrT,b.nowy)•(Tmax,cieply)•(Pmax,5)•(HT,1)•(MemC,0)
tNorthwoodC
=
(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}.
15 z 19
Udzielamy więc odpowiedź całkowitą:
σ(t) = σ t1∪σ t2 = Ø∪{12,13 ,14 ,15 } = {12,13,14,15}
Ponownie korzystając z funkcji adresowej otrzymujemy ostateczny wynik czytelny dla użytkownika:
σ(t) = {NorthwoodA, NorthwoodB, NorthwoodC, Prestonia}.
Przykład 2 – wstawianie nowego obiektu
Niech dane nam będzie zadanie wstawienia informacji o procesorze Nocona. Mamy dane po
zinterpretowaniu tekstu normalnego takie informacje o jądrze 64bitowym Intela architekturalnie zgodnym
wstecznie przedstawione w formie adekwatnej do naszej kartoteki wtórnej:
.
.
.
37
38
39
40
SledgeHammer
Newcastle
ClawHammer
Nocoma
A64
A64
A64
X
O1
O1
O1
L
Wow!
Tlum
Wow!
Wow!
9a
9b
7c
I
O
O
O
O
4
4
4
4
Szybki
Szybki
Szybki
Hyper
b.nowy
b.nowy
b.nowy
Mikro
Parzy
Chlodny
Parzy
Chlodny
5
5
5
5
0
0
0
1
2
1
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:
α(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:
.
.
.
16 z 19
37
38
39
40
SledgeHammer
Newcastle
ClawHammer
Nocoma
A64
A64
A64
X
O1
O1
O1
I
Wow!
Tlum
Wow!
Wow!
9a
9b
7c
I
O
O
O
O
4
4
4
4
Szybki
Szybki
Szybki
Hyper
b.nowy
b.nowy
b.nowy
Mikro
Parzy
Chlodny
Parzy
Chlodny
5
5
5
5
0
0
0
1
2
1
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:
.
.
.
37 SledgeHammer
38
Newcastle
39 ClawHammer
40
Nocoma
A64
A64
A64
X
O1
O1
O1
I
Wow!
Tlum
Wow!
Wow!
9a
9b
7c
I
O
O
O
O
4
4
4
4
Szybki
Szybki
Szybki
b.szybki
b.nowy Parzy
b.nowy Chlodny
b.nowy Parzy
Mikro Chlodny
5
5
5
5
0
0
0
1
2
1
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}
α(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}
17 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 = (∑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 >
τg). Modyfikacje mogą prowadzić do dodania czasu przeglądu list, zatem czas wyszukiwania będzie
równy:
τ' = τ + τ0 ,
18 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 ;-)
19 z 19

SWI - MLI

Transkrypt

Podobne dokumenty

metoda list prostych - Zakład Systemów Informatycznych

BRIEF 3: Wydarzenie korporacyjne – Launch