Optimierung Aspektorientierte Programmierung Folie: 1 Übersicht Optimierung 1.Bedeutung 2.Resource-Pooling im Allgemeinen 3.Database Connection Pooling.

Präsentation zum Thema: "Optimierung Aspektorientierte Programmierung Folie: 1 Übersicht Optimierung 1.Bedeutung 2.Resource-Pooling im Allgemeinen 3.Database Connection Pooling."—  Präsentation transkript:

1 Optimierung Aspektorientierte Programmierung Folie: 1 Übersicht Optimierung 1.Bedeutung 2.Resource-Pooling im Allgemeinen 3.Database Connection Pooling 4.Thread-Pooling 5.Caching Christian Wettstaedt, 21.06.06

2 Optimierung Aspektorientierte Programmierung Folie: 2 1. Bedeutung Wozu Optimierung?  Verbesserung der Effizienz eines Computerprogramms Aber:Optimierung im System ist meist nebensächlig und werden daher erst sehr spät umgesetzt  Massive Eingriffe in Design und Implementation nötig  viele betroffene Module -> “crosscutting concern” => Abhilfe durch AOP

3 Optimierung Aspektorientierte Programmierung Folie: 3 2. Allgemeines Resource Pooling Was ist “Resource Pooling”? - “to pool” = etwas zusammenlegen, konzentrieren  die Möglichkeit zur Speicherung und Wiederver- wendung einer bestimmten Ressource  bringt Performance, da das Bereitstellen bzw. Entsorgen einer Ressource sehr aufwendig sein kann Ressourcen: z.B. eine Datenbankverbindung - Auf- und Abbau der Verbindung kann mehr Zeit kosten als die eigentliche DB-Transaktion

4 Optimierung Aspektorientierte Programmierung Folie: 4 2. Allgemeines Resource Pooling Logik des “Resource Pooling”  2 Basis-Methoden zur Implementation des pools nötig:  1) Relevante Ressource aus dem pool beziehen  2) Eine Ressource in den pool geben

5 Optimierung Aspektorientierte Programmierung Folie: 5 Typische Umsetzung: public interface ResourcePool { public Resource getResource(ResourceDescription rd); public boolean putResource(Resource r); } 2. Allgemeines Resource Pooling gibt null zurück, falls Ressource nicht im pool ist gibt false zurück, falls Ressource nicht in den pool gegeben werden kann (z.B. wenn er voll ist)

6 Optimierung Aspektorientierte Programmierung Folie: 6 Typische Anwendung im Code: … Resource resource = resPool.getResource(rd); if (resource == null) { resource = resourceFactory.createResource(rd); }... // Benutzen der Ressource... if (resPool.putResource(resource) == false) { resource.dispose(); } 2. Allgemeines Resource Pooling

7 Optimierung Aspektorientierte Programmierung Folie: 7 2. Allgemeines Resource Pooling Ablaufslogik des Resource Pooling

8 Optimierung Aspektorientierte Programmierung Folie: 8 2. Allgemeines Resource Pooling Nachteile und Probleme des Resource Pooling:  benötigt extra Speicherplatz (“space/time tradeoff”)  Berücksichtigung bei der Entwicklung (“architects’s dilemma”)  Früh: längere Entwicklungszeiten  Spät: meist massiver Eingriff im System nötig  Lösung: Design mittels Aspekten weiterer Vorteil: pooling kann auch komplett abgeschalten werden

9 Optimierung Aspektorientierte Programmierung Folie: 9 Design mittels Aspekten:  2 pointcuts nötig:Abfangen der join-points, an welchen eine Ressource bereitgestellt bzw. entsorgt wird public aspect ResourcePoolingAspect { private ResourcePool _rpool = new ResourcePoolImpl(); pointcut resourceCreation(ResourceDescription rd) : ; pointcut resourceDestruction(Resource r) : ; Resource around(ResourceDescription rd) : resourceCreation(rd) { Resource resource = _rpool.getResource(rd); if (resource == null) resource = proceed(rd); return resource; } void around(Resource r) : resourceDestruction(r) { if ( !_rpool.putResource(r)) proceed(r); } 2. Allgemeines Resource Pooling

10 Optimierung Aspektorientierte Programmierung Folie: 10 2. Allgemeines Resource Pooling Logik des Resource Pooling mit Aspekten

11 Optimierung Aspektorientierte Programmierung Folie: 11 3. Database-Connection Pooling Verbindung aufbauen (url, user, password) Verbindung schließen pool Verbindung im pool? ja nimm Verbindung aus pool url, user, password nein url, user, password Erzeuge neue Verbindung SELECT * FROM A WHERE B DB “database-connection-pooling” bereits im JDBC 2.0 enthalten Client Sichtbar Intern (JDBC bzw. Aspect) url, user, password gib aktuelle Verbindung in den pool

12 Optimierung Aspektorientierte Programmierung Folie: 12  Ein typisches DB-Connection-pool interface: import java.sql.*; public interface DBConnectionPool { public Connection getConnection(String url, String userName, String password) throws SQLException; public boolean putConnection(Connection connection); public void registerConnection(Connection connection, String url, String userName, String password); } 3. Database-Connection Pooling Registriert eine Verbindung nach ihrer Erzeugung →Konventioneller Weg: Anpassen jeder Methode zum Erzeugen bzw. Schließen einer Verbindung (siehe Folie 6) →AOP: Kapselung der Logik in einem Aspekt ohne vorhandenen Code zu verändern

13 Optimierung Aspektorientierte Programmierung Folie: 13 3. Database-Connection Pooling Anforderungen an den Pooling Aspect Ressource Ressource-Pool Ressourcenbeschreibung java.sql.Connection Implementation des URL, UserName, Password DBConnectionPool interface Ressourcen-Erzeugung Ressourcen-Zerstörung pointcut: DriverManager.getConnection() pointcut: Connection.close()

14 Optimierung Aspektorientierte Programmierung Folie: 14 3. Database-Connection Pooling import java.sql.*; public aspect DBConnectionPoolingAspect { DBConnectionPool _connPool = new SimpleDBConnectionPool(); pointcut connectionCreation(String url, String username, String password) : call(public static Connection DriverManager.getConnection(String, String, String)) && args(url, username, password); pointcut connectionRelease(Connection connection) : call(public void Connection.close()) && target(connection); Connection around(String url, String username, String password) throws SQLException : connectionCreation(url, userName, password) { Connection connection = _connPool.getConnection(url, username, password); if (connection == null) { connection = proceed(url, username, password); _connPool.registerConnection(connection, url, username, password); } return connection; } void around(Connection connection) : connectionRelease(connection) { if ( !_connPool.putConnection(connection)) { proceed(connection); }

15 Optimierung Aspektorientierte Programmierung Folie: 15 Was ist noch nötig?  die Identifikation der Verbindung durch den pool Aber: Die Klasse Connection hat kein API zur Identifikation Abhilfe: Eine Klasse, die alle Eigenschaften einer Verbindung bündelt public class DBConnectionDescription { private String _url; private String _userName; private String _password; public DBConnectionDescription(String url, String userName, String password) { _url = url; _userName = userName; _password = password; } 3. Database-Connection Pooling

16 Optimierung Aspektorientierte Programmierung Folie: 16 Die Implementation des DBConnectionPool interface: import java.sql.*; import java.util.*; public class SimpleDBConnectionPool implements DBConnectionPool { List _pooledConnections = new ArrayList(); Map _connectionDescriptionMap = new HashMap(); synchronized public Connection getConnection(String url, String userName, String password) throws SQLException { DBConnectionDescription desc = new DBConnectionDescription(url, userName,password); List connectionsList = (List) _connectionDescriptionMap.get(desc); if (connectionsList == null) return null; for (int size = _pooledConnections.size(), i = 0; i < size; ++i) { Connection connection = (Connection) _pooledConnections.get(i); if (connectionsList.contains(connection)) { _pooledConnections.remove(connection); return connection; } return null; }  3. Database-Connection Pooling

17 Optimierung Aspektorientierte Programmierung Folie: 17 3. Database-Connection Pooling synchronized public boolean putConnection(Connection connection) { _pooledConnections.add(connection); return true; } synchronized public void registerConnection(Connection connection, String url, String userName, String password) { DBConnectionDescription desc = new DBConnectionDescription(url, userName, password); List connectionsList = (List) _connectionDescriptionMap.get(desc); if (connectionsList == null) { connectionsList = new ArrayList(); _connectionDescriptionMap.put(desc, connectionsList); } connectionsList.add(connection); } Anmerkung: hier keine Größenbeschränkung des pools  putConnection() liefert immer true zurück

18 Optimierung Aspektorientierte Programmierung Folie: 18 Überprüfen des poolings mittels einer Testklasse: import java.sql.*; public class Test { … static void printTable(String url, String table, String user, String password) throws SQLException { …// Aufbau, Nutzen und Schließen einer DB-Verbindung } printTable(“jdbc:odbc:Stock”, “price”, “user1”, “password1”); printTable(“jdbc:odbc:Stock”, “price”, “user2”, “password2”); printTable(“jdbc:odbc:Stock”, “price”, “user1”, “password1”); printTable(“jdbc:odbc:Stock”, “price”, “user2”, “password2”); } 3. Database-Connection Pooling simples Wiederholen der DB-Interaktionen zum testen des poolings Methode printtable(url, table, user, password):  1. Baut eine Verbindung auf (url, user, password)  2. Liest Daten per SQL (SELECT * FROM table)  3. Gibt die Daten aus und schließt die Verbindung

19 Optimierung Aspektorientierte Programmierung Folie: 19 Ein Aspect zum Aufzeichnen der Arbeitsweise: import java.sql.*; public aspect DBConnectionPoolLoggingAspect{ declare precedence *, DBConnectionPoolLoggingAspect; after(…) : call(Connection DriverManager.getConnection(…)) … { System.out.println(“For [“ + url + “,” + username + “,” + password + “]” + “/n/tCreated new : “ + connection); } after(…) : call(Connection DBConnectionPool.getConnection(…)) … {…} before(…) : call(* DBConnectionPool.putConnection(…)) … {…} before(…) : call(* Connection.close()) … {…} } 3. Database-Connection Pooling

20 Optimierung Aspektorientierte Programmierung Folie: 20 3. Database-Connection Pooling For [jdbc:odbc:stock,user1,password1] Got from pool: null For [jdbc:odbc:stock,user1,password1] Created new : sun.jdbc.odbc.JdbcOdbcConnection@1cfb549 sunw 22 ibm 100 Putting in pool: sun.jdbc.odbc.JdbcOdbcConnection@1cfb549 For [jdbc:odbc:stock,user2,password2] Got from pool: null For [jdbc:odbc:stock,user2,password2] Created new : sun.jdbc.odbc.JdbcOdbcConnection@422ede sunw 22 ibm 100 Putting in pool: sun.jdbc.odbc.JdbcOdbcConnection@422ede For [jdbc:odbc:stock,user1,password1] Got from pool: sun.jdbc.odbc.JdbcOdbcConnection@1cfb549 sunw 22 ibm 100 Putting in pool: sun.jdbc.odbc.JdbcOdbcConnection@1cfb549 For [jdbc:odbc:stock,user2,password2] Got from pool: sun.jdbc.odbc.JdbcOdbcConnection@422ede sunw 22 ibm 100 Putting in pool: sun.jdbc.odbc.JdbcOdbcConnection@422ede Ausgabe: Datenbank Einträge

21 Optimierung Aspektorientierte Programmierung Folie: 21 3. Database-Connection Pooling Mögliche Erweiterungen:  Größe des pools beschränken  Beschränkung der Zeit, die eine Verbindung aufbewahrt wird  Pooling nicht für das ganze System, sondern nur für einzelne Clienten nutzbar machen

22 Optimierung Aspektorientierte Programmierung Folie: 22 4. Thread Pooling Was ist ein Thread? Thread = dt. “Faden” -> ein “Ausführungsstrang” in der Informatik  Eine nebenläufige Ausführungseinheit innerhalb eines Prozesses  Mehrere Threads teilen sich dessen Betriebssystemmittel (Speicher, CPU-Zeit etc.)  Zustände: Bereit Laufend Wartend Beendet

23 Optimierung Aspektorientierte Programmierung Folie: 23 4. Thread Pooling Threads in Java: Erben von Klasse Thread oder implementieren das Interface Runnable start():ruft Thread auf und führt run() aus (Bereit->Laufend) run():Implementation der Thread-Aktion(Laufend) wait():versetzt Thread in Wartezustand(Laufend->Wartend) notify(): reaktiviert einen Thread(Wartend->Laufend) Der Thread ist beendet, wenn run() verlassen wird

24 Optimierung Aspektorientierte Programmierung Folie: 24  Anstatt einen Thread zu beenden -> Thread in einem pool aufbewahren Thread pooling interface: public interface ThreadPool{ public boolean putThread(Thread thread); public Thread getThread(); public boolean wakeupThread(Thread thread); } 4. Thread Pooling Gib Thread in pool und setze Ihn in Wartend-Modus Gib false zurück, wenn Thread nicht reaktiviert werden kann Hole Thread aus pool (gib Benutzrecht an den Aufrufer) ->Thread noch immer im Wartend-Modus

25 Optimierung Aspektorientierte Programmierung Folie: 25 Beispiel: simples Kommunizieren von mehreren clients mit einem server mittels eines Threads EchoServer 1.Erstellt ein server-socket (Schnittstelle) 2.Wartet auf eingehende Verbindungen 3.Erzeugt einen neuen Thread pro eingehender Verbindung  Logik des Threads in einer extra Klasse (worker-class) (beinhaltet die run() Methode des Threads) 1.Initialisiert ein Eingabe-Stream an dem socket 2.Liest einen Text vom Eingabe-Stream (d.h. vom client) 3.Gibt den gelesenen Text an die Konsole aus > System.out.println(“Got request : “ + requestString); 4. Thread Pooling

26 Optimierung Aspektorientierte Programmierung Folie: 26 Aber: Der Thread soll für verschiedene Aufgaben einsetzbar sein! (d.h. er soll verschiedene worker-objects haben können) →die worker-class wird ausschließlich bei der Konstruktion des Thread aufgerufen Lösung: Eine extra Klasse zum Zuweisen eines worker-objects (d.h. dessen run() Methode) zu einem Thread public class DelegatingThread extends Thread { private Runnable _delegatee; public void setDelegatee(Runnable delegatee) { _delegatee = delegatee; } Public void run() { _delegatee.run() } 4. Thread Pooling

27 Optimierung Aspektorientierte Programmierung Folie: 27 4. Thread Pooling DelegatingThread _delegatee _delegatee.run() workerObject1 run() workerObject2 run() Thread workerObject run() Code server-class: Runnable worker = new Echoworker(requestSocket); Thread serverThread = new Thread(worker); call pointcut serverThread Ein Thread, aber verschiedene run() Methoden möglich

28 Optimierung Aspektorientierte Programmierung Folie: 28 4. Thread Pooling Anforderungen an den Pooling Aspect Ressource Ressource-Pool Ressourcenbeschreibung java.lang.Thread Implementation des unrelevant, da zwischen Threads ThreadPool interface nicht unterschieden wird Ressourcen-Erzeugung Ressourcen-Zerstörung pointcut: Thread.new() pointcut: Thread.run() beendet pointcut: Thread.start()

29 Optimierung Aspektorientierte Programmierung Folie: 29 ThreadPoolingAspect.java public aspect ThreadPoolingAspect { ThreadPool _pool = new SimpleThreadPool(); pointcut threadCreation(Runnable worker) : call(Thread.new(Runnable)) && args(worker); pointcut session(DelegatingThread thread) : execution(void DelegatingThread.run()) && this(thread); pointcut threadStart(DelegatingThread thread) : call(void Thread.start()) && target(thread); Thread around(Runnable worker) : threadCreation(worker) { DelegatingThread availableThread = (DelegatingThread) _pool.getThread(); if (availableThread == null) availableThread = new DelegatingThread(); availableThread.setDelegatee(worker); return availableThread; } void around(DelegatingThread thread) : session(thread) { while (true) { proceed(thread); _pool.putThread(thread); } void around(Thread thread) : threadStart(thread) { if (!_pool.wakeupThread(thread)) proceed(thread); } 4. Thread Pooling

30 Optimierung Aspektorientierte Programmierung Folie: 30 SimpleThreadPool.java public class SimpleThreadPool implements ThreadPool { List _waitingThreads = new ArrayList(); synchronized public boolean putThread(Thread thread) { _waitingThreads.add(thread); thread.wait(); return true; } synchronized public Thread getThread() { if (!_waitingThreads.isEmpty()) { Thread availableThread = (Thread) _waitingThreads.remove(0); return availableThread; } return null; } synchronized public boolean wakeupThread(Thread thread) { if (thread.isAlive()) { thread.notify(); return true; } return false; } 4. Thread Pooling

31 Optimierung Aspektorientierte Programmierung Folie: 31 4. Thread Pooling Client pool WO Thread.new()Thread.Start()Thread.run() Thread im pool?  ja Nimm Thread aus pool (Zustand: Wartend)  nein Erzeuge neuen Thread (Zustand: Bereit) workerObject zuweisen Thread aus pool?  ja  nein Starte Thread.Start() Wecke Thread.notify() Abarbeitung der Thread Aktion.run() Anstatt zu beenden (run() wird verlassen) gib Thread in pool (Zustand: Wartend) Endlosschleife Sichtbar Intern.wait()

32 Optimierung Aspektorientierte Programmierung Folie: 32 server 4. Thread Pooling Test mittels eines Test-Clients (EchoClient.java) 1.Erstellt einen client-socket (TCP/IP Schnittstelle) 2.Initialisiert einen Ausgabe-Stream an dem socket 3.Liest Benutzereingaben und gibt diese weiter an den Ausgabe-Stream und somit zum server > java EchoClient host port > Deutschland > wird > Weltmeister > quit >got request: Deutschland >got request: wird >got request: Weltmeister >Ending the session port

33 Optimierung Aspektorientierte Programmierung Folie: 33 4. Thread Pooling Aufzeichnen der Interaktionen mittels eines Aspects: public aspect ThreadPoolLoggingAspect{ after() returning(Thread thread) : execution(Thread ThreadPool.getThread(..)) { System.out.println(“Got from pool: “ + thread); } before(Thread thread) : execution(boolean ThreadPool.putThread(Thread)) … System.out.println(“Putting in pool: “ + thread + “\n”); } before(Thread thread) : execution(boolean ThreadPool.wakeupThread(Thread)) … System.out.println(“Waking up: “ + thread); }

34 Optimierung Aspektorientierte Programmierung Folie: 34 4. Thread Pooling Aufruf des servers:  java EchoServer 10000 Aufruf von 2 clients und Eingabe einiger Strings:  java EchoClient localhost 10000 quit Ausgabe: Got from pool: null Waking up: Thread[Thread-1,5,main] Got request: First string Interaktion mit dem 1. Client Got request: Second string Ending the session Putting in pool: Thread[Thread-1,5,main] Got from pool: Thread[Thread-1,5,main] Waking up: Thread[Thread-1,5,main] Got request: Third string Interaktion mit dem 2. Client Got request: Fourth string Ending the session Putting in pool: Thread[Thread-1,5,main]

35 Optimierung Aspektorientierte Programmierung Folie: 35 5. Caching Pooling: Ein exklusiver Benutzer einer Resource zu einem bestimmten Zeitpunkt Caching:Multiple Zugriffe auf eine Ressource erlaubt Beispiele:  simples Datenbank-Caching  XSLT caching (Extensible Stylesheet Language Transformation) →Sprache zum Umwandeln von XML Dokumenten in z.B. HTML, PDF etc. Hier: Performancezuwachs durch Wiederverwendung des Transformers

36 Optimierung Aspektorientierte Programmierung Folie: 36 simples Beispiel:Speichern von oft verwendeten DB-Einträgen in einem Cache  Abfangen der join-points von query() und insert() der Klasse DBManager public aspect CacheManager { Map cache = new hashmap(); pointcut DBquery(String request) : call(Vector DBManager.query(String)) && args(request); Vector around(String request) : DBquery(request) { Vector result = cache.get(request); if (result == null) { result = proceed(request); cache.put(request,result); } return result; }  5. Caching

37 Optimierung Aspektorientierte Programmierung Folie: 37 5. Caching  prüfen, ob bei einem Schreibvorgang ein Cache-Eintrag ungültig wird  pointcut DBinsert(String request) : call(Vector DBManager.insert(String)) && args(request); before(String request) : DBinsert(request) { if (cache.containsKey(request) == true) { cache.remove(request); } ist der Eintrag im Cache gespeichert, dann lösche diesen um Inkonsistenten zu vermeiden

38 Optimierung Aspektorientierte Programmierung Folie: 38 XSLT-Caching: import java.xml.transform.*; … public class Test { public static void main(String[] args) throws Exception { printTableRaw(“input1.xml”); printTablePretty(“input1.xml”); printTableRaw(“input2.xml”); printTablePretty(“input2.xml”); } private static void printTableRaw(String xmlFile) throws … { TransformerFactory tFactory = TransformerFactory.newInstance(); Transformer transformer = tFactory.newTransformer( new StreamSource(new File(“tableRaw.xsl”))); // Benutzen des Transformers } private static void printTablePretty(String xmlFile) throws … { TransformerFactory tFactory = TransformerFactory.newInstance(); Transformer transformer = tFactory.newTransformer( new StreamSource(new File(“tablePretty.xsl”))); // Benutzen des Transformers } 5. Caching Erstellt jeweils ein neues Transformer Objekt

39 Optimierung Aspektorientierte Programmierung Folie: 39 Logik des Caching hier: →Speichern und Wiederverwenden der Transformer für tableRaw.xsl und TablePretty.xsl import javax.xml.transform.*; public aspect TransformerCacheAspect { Map _cache = new Hashtable(); pointcut transformerCreation(Source source) : call( * TransformerFactory.newTransformer(..)) && args(source); Transformer around(Source source) throws TransformerConfigurationException : transformerCreation(source) { Transformer transformer = (Transformer) _cache.get(source.getSystemId()); if (transformer == null) { transformer = proceed(source); _cache.put(source.getSystemId(), transformer); } return transformer; } 5. Caching Das Argument des Transformers dient zur Identifikation im pool

40 Optimierung Aspektorientierte Programmierung Folie: 40 5. Caching Aufzeichnen der Arbeitsweise mittels eines Aspects →Ausgabe: > ajc Test.java LogTransformerCreation.java TransformerCacheAspect.java > java Test Obtained transformer for: file:///F:/stylesheets/tableRaw.xsl org.apache.xalan.transformer.TransformerImpl@1b26af3 Obtained transformer for: file:///F:/stylesheets/tablePretty.xsl org.apache.xalan.transformer.TransformerImpl@1feca64 Obtained transformer for: file:///F:/stylesheets/tableRaw.xsl org.apache.xalan.transformer.TransformerImpl@1b26af3 Obtained transformer for: file:///F:/stylesheets/tablePretty.xsl org.apache.xalan.transformer.TransformerImpl@1feca64 Wiederverwendung der Transformer

41 Optimierung Aspektorientierte Programmierung Folie: 41 6. Zusammenfassung Was wurde nicht beachtet? →Eine zwischengespeicherte Ressource wurde nie komplett gelöscht -> mögliches OutOfMemory Problem Aber: Pooling und Caching wurde durch AOP denkbar vereinfacht →Keine Systemweiten Codeänderungen nötig →Optimierung kann auch einfach ausgeschalten werden

42 Optimierung Aspektorientierte Programmierung Folie: 42 Literaturangaben  Ramnivas Laddad: „AspectJ in Action“ (Manning), S. 203 – 242  Folie 36-37 (simples DB Caching): Diplomarbeit Götz Bundschuh, TU Darmstadt (2002), S.52 – 55 Anmerkung: Die hier vorgestellten Code Beispiele wurden zu Demonstrations- zwecken stark vereinfacht und stellen ohne Änderung keine gute Implementation des Pooling bzw. Cachings dar.