07.11.2005 Janick Martinez [email protected] 1 Performancebetrachtung typischer...

07.11.2005Janick Martinez

[email protected] 1

Performancebetrachtung typischer XML-Operationen

Seminar XML und intelligente SystemeWintersemester 05/06

Uni Bielefeld

Janick Martinez 2 / 1907.11.2005

Lebenszyklus eines XML-Dokuments

ParsenParsen ZugriffZugriff ModifikationModifikation SerialisierungSerialisierung


Gliederung des Vortrages

Komplexitätsanalyse XML-Dokumente im Speicher elementare XML-Operationen

Zugriff auf bestimmte KnotenTestrelationenDatenstruktur-Modifikationen

komplexe XML-Operationen


Komplexitätsanalyse

Einteilung von Algorithmen in Komplexitätsklassen O(f) „obere Schranke“ Θ(f) „obere und untere Schranke“ Ω(f) „untere Schranke“

„Reduktion auf Funktion der höchsten Ordnung und Abstraktion von konstanten Faktoren“

Beispiel: 5n²+3n Die Funktion 5n²+3n „wächst im wesentlichen nicht

schneller“ als die Funktion n²

O(?)O(n²)


Beispiel Komplexitätsanalyse

Funktion zur Ermittlung des Mini- / Maximums eines Arrays

Bestimmende Eingabegröße: Länge des Arrays

Bestimmende Operation: „Vergleichen“

min = array[0]max = array[0]i = 1while (i < array.length())

if(array[i] < min) thenmin = array[i]

if(array[i] > max) thenmax = array[i]

i++end

Schleife wird n-1 mal ausgeführt

Pro Durchlauf je-weils ein Vergleich

ZeitkostenfunktionT(n) = 2(n-1)

2(n-1)

Ermittlung des Mini- / Maximums erfordert lineare Zeit

O(n)


Bestimmende Eingabegrößen

Gesamtanzahl an Elementen

Anzahl Kinder eines Knotens

Tiefe des Baumes

number of elements

fanout

depth

Bibliothek

Buch 1 Buch 2 Buch n

Autor Titel ISBN Ausleihliste

Entleiher 1 Entleiher n

Bibliothek

Buch 1 Buch 2 Buch n



Bibliothek

Buch 1 Buch 2



Bibliothek

Buch 1 Buch 2



Buch m

„typisch“ < 10

„typisch“ 8 - 13


XML-Elementen im Speicher

Knoten

Children[ ]

…

Felder (arrays)Kern: indizierte Feld-Elementesehr schneller Zugriff in

konstanter ZeitSpeicherschonendUnvorteilhaft im Zusammen-

hang mit Datenstruktur-modifikationen

1

2

34

x

n-1

n

Kind 2

Children[ ]

…

Kind x

Children[ ]

…

Kind n

Children[ ]

…

Feld-Indices

O(1)O(n)


XML-Elementen im Speicher

Knoten

myParent

firstChild

nextSibling…

Kind 1

myParent

firstChild

nextSibling…

Kind 2

myParent

firstChild

nextSibling…

Kind 3

myParent

firstChild

nextSibling…

Verknüpfte Liste (Linked-Lists) Kern: Referenzen auf Knoten Relativ schneller Zugriff Etwas speicherbelastender als Arrays

Hierarchische Struktur leicht aufzubauen

Vorteilhaft im Zusammen-hang mit Datenstruktur-modifikationen

O(n)

O(n + fanout*depth)


XML-Elementen im Speicher Auslassende Liste (Skip-Lists)

Spezielle Erweiterung einer Linked-List Auf Wahrscheinlichkeitsverteilungen basierend Schneller Zugriff auf einzelne

Elemente

Nur geringfügig erhöhterSpeicherverbrauch

Erst sinnvoll bei größeremfanout

Kopf Terminator

max Layer

n´ter Layer

Kind 1 Kind 2 Kind 3 Kind 4 Kind 5

O(log(n))


Zugriff auf bestimmte Knoten

Suchliste vom Parser aufgebaut Kostet zusätzliche Zeit

Array Linked-List Skip-ListOperationDatenstruktur

Verwendung von Referenzen firstChild und nextSibling

Attribute und Text direkt mit Knoten assoziiert Speicherung innerhalb des Knotens Referenzierung der Daten

Knoten mit ID/Key X• seriell

O(number of elements)

• per Suchliste (z.B. HashTable) ≈ O(1)

N-te Kind von Knoten Y O(1) O(fanout) O(log(fanout))

Attribut- und Textzugriff eines Knoten

O(1)


Mögliche Gefahr durch getChildN()

i = 0while (i < lastChildNumber)

child = parentNode.getChildN(i)myNodeList.add(node)i++

end

Beabsichtigt: ersten N Kinder eines Knotens erhalten

Hier: getChildN() mit Referenzen

firstChild und nextSibling realisiert

O(fanout²)

Bessere Alternative: direkter Gebrauch der nextSibling Referenz des gefundenen Kindes

O(fanout)


Zugriff auf andere VerwandteAm Beispiel vorherigen Geschwister 1. Wie im vorherigen Code-Beispiel

2. Durch zusätzliche Referenzen

Rechenintensiv

Speicherintensiv

Allgemeiner Trade-Off

Rechenzeit Speicher


Testrelationen

Überprüfung, obX.getParent() == Y.getParent()


Überprüfung, ob X.getParent() == Y Iteration über alle Vorfahren von X mittels X.getParent() und Überprüfung, ob Y gefunden wurde

O(1)X.isSiblingOf(Y)

X.isChildOf(Y)

X. isDescendantOf(Y)

O(1)

O(depth)


Beispiel: X.isDescendantOf(Y)

parentNode = nodeX.getParent()while (parentNode != null)

if(parentNode == nodeY) thenreturn true

parentNode = parentNode.getParent()endreturn false

wird maximal depth-1 mal ausgeführt

O(depth)


Datenstrukturmodifikationen

Einfügposition kann in linearer Zeit gefunden werden Laufzeit abhängig von zu aktualisierenden Referenzen auf

und innerhalb des neuen Knotens sowie von Bezügen wie „Anzahl Kinder“, Kosten hierfür aber konstant

Architekturabhängig 1. Kinder des eingefügten Knotens direkt mit eingefügt 2. Vorgang muss iterativ für jedes Kind wiederholt werden


Laufzeit wie beim Einfügen abhängig von zu aktualisierenden Referenzen und Bezügen

Reduziert sich auf das Löschen des Knotens an der alten und Einfügen an der neuen Position

Knoten einfügen

Knoten löschen

Knoten bewegen

O(fanout)

O(fanout)

O(fanout)

O(fanout) O(log(fanout)) / O(1)

O(fanout) / O(1) O(log(fanout)) / O(1)

O(fanout) O(log(fanout))

Problem von Arrays: Begrenzte Größe Array muß neu angelegt werden, benötigt lineare Zeit Aber: impraktikabeler konstanter Faktor sehr hoch

Einfügposition kann in logarithmischer Zeit ermittelt werden Konstanter Faktor jedoch leicht höher als bei einer Linked-List

Ebenfalls hoher konstanter Faktor wie beim Einfügen

/ O(1)


Beispiel: Einfügen in Linked-ListparentNode.incrementChildNumber()newNode.setParent(parentNode)if(n == 0) then

newNode.setFollowing(parentNode.getFirstChild())parentNode.setFirstChild(newNode)return

precidingSibbling = parentNode.getFirstChild()i = 1while (i < n)

precidingSibbling = precidingSibbling.getNextSibbling()i++

endnewNode.setFollowing(precidingSibbling.getNextSibbling())precidingSibbling.setNextSibbling(newNode)

Funktion zum Einfügen eines neuen Knotens newNode an die Stelle n

O(1)

O(1)

O(1)

wird maximal fanout-1 mal ausgeführt O(fanout)

O(fanout)


Komplexe XML-Operationen

Komplexe XML-OperationenMachen starken Gebrauch und sind

zusammengesetzt aus elementaren OperationenLaufzeit der primitiveren Operationen ist

ausschlaggebend für die der komplexeren Operationen


Beispiel: Alle Kinder mit Attribut X = Y

children = node.getChildren()

while (children.hasNext())

currentChild = children.next()

if (currentChild.getAttribute(X) == Y)

then myNodeList.add(currentChild)

end

return myNodeList

Funktion zur Ermittlung aller Kinder eines Knotens mit bestimmten Attribut

XPath: /node/child[@X=Y] Nutzt primitivere Operationen

getChildren() und getAttribute()

O(fanout)

O(fanout)

O(fanout)

O(1)

Laufzeitabhängigkeit von elementaren Operationen Bspw: schlechtere Implementierung von getChildren() mit O(fanout²)

O(fanout²)


Fazit

Quellen S. DeRose, „Architecture and Speed of Common XML Operations“, Extreme Markup Languages 2005,

August 2005 Google…

Interne API Implementierung sollte bekannt sein und berücksichtigt werden, um effiziente XML verarbeitende Programme zu erstellen

XML bringt keine neuen Erkenntnisse im Bezug auf effiziente Datenverarbeitung, sondern baut auf verlässlichen Algorithmen auf

Zum Abschluss:

Beispielhaftes Benchmark der XOM Java Implementierung


Benchmark XOM API

1. Element einfügenAm Beginn In die MitteAn das Ende

2. Element bewegenVom Anfang an das EndeVom Ende zum Anfang

3. Bewegen komplexer ElementeREC chrmed med chrbig big

Größe(bytes) 159339 893821 1264240 3417181 5052472

Markup Dichte 34% 6% 33% 2% 33%

07.11.2005 Janick Martinez [email protected] 1 Performancebetrachtung typischer...

Documents

Transcript of 07.11.2005 Janick Martinez [email protected] 1 Performancebetrachtung typischer...