Advanced Developers Conference
10.-11. Oktober 2004




                                                                 B...
Advanced Developers Conference
10.-11. Oktober 2004




                                                                  ...
Advanced Developers Conference
10.-11. Oktober 2004




                                                                  ...
Advanced Developers Conference
10.-11. Oktober 2004




                                                                  ...
Advanced Developers Conference
10.-11. Oktober 2004




                                                                  ...
Advanced Developers Conference
10.-11. Oktober 2004




                                               Bemerkungen
       ...
Advanced Developers Conference
10.-11. Oktober 2004




                             Connection Establishment
            ...
Advanced Developers Conference
10.-11. Oktober 2004




                             Acceptor-Connector:
                 ...
Advanced Developers Conference
10.-11. Oktober 2004




                           Acceptor-Connector:
                   ...
Advanced Developers Conference
10.-11. Oktober 2004




                         Acceptor-Connector:
                     ...
Advanced Developers Conference
10.-11. Oktober 2004




                                                                  ...
Advanced Developers Conference
10.-11. Oktober 2004




                            Leader/Followers:
                    ...
Advanced Developers Conference
10.-11. Oktober 2004




                            Leader/Followers:
                    ...
Advanced Developers Conference
10.-11. Oktober 2004




                         Leader/Followers:
                       ...
Advanced Developers Conference
10.-11. Oktober 2004




                                Concurrency Coordination
         ...
Advanced Developers Conference
10.-11. Oktober 2004




                                                                  ...
Advanced Developers Conference
10.-11. Oktober 2004




                                                                  ...
Advanced Developers Conference
10.-11. Oktober 2004




                                                                  ...
Advanced Developers Conference
10.-11. Oktober 2004




                            Efficient Content Access
             ...
Advanced Developers Conference
10.-11. Oktober 2004




                                                                  ...
Advanced Developers Conference
10.-11. Oktober 2004




                                                                  ...
Advanced Developers Conference
10.-11. Oktober 2004




                                                               Bem...
Advanced Developers Conference
10.-11. Oktober 2004




                                                                  ...
Tutorial on Constructing a Web-Server with Patterns at ADC 2004
Tutorial on Constructing a Web-Server with Patterns at ADC 2004
Tutorial on Constructing a Web-Server with Patterns at ADC 2004
Tutorial on Constructing a Web-Server with Patterns at ADC 2004
Tutorial on Constructing a Web-Server with Patterns at ADC 2004
Tutorial on Constructing a Web-Server with Patterns at ADC 2004
Tutorial on Constructing a Web-Server with Patterns at ADC 2004
Tutorial on Constructing a Web-Server with Patterns at ADC 2004
Tutorial on Constructing a Web-Server with Patterns at ADC 2004
Tutorial on Constructing a Web-Server with Patterns at ADC 2004
Tutorial on Constructing a Web-Server with Patterns at ADC 2004
Tutorial on Constructing a Web-Server with Patterns at ADC 2004
Tutorial on Constructing a Web-Server with Patterns at ADC 2004
Tutorial on Constructing a Web-Server with Patterns at ADC 2004
Tutorial on Constructing a Web-Server with Patterns at ADC 2004
Tutorial on Constructing a Web-Server with Patterns at ADC 2004
Tutorial on Constructing a Web-Server with Patterns at ADC 2004
Tutorial on Constructing a Web-Server with Patterns at ADC 2004
Tutorial on Constructing a Web-Server with Patterns at ADC 2004
Tutorial on Constructing a Web-Server with Patterns at ADC 2004
Tutorial on Constructing a Web-Server with Patterns at ADC 2004
Tutorial on Constructing a Web-Server with Patterns at ADC 2004
Tutorial on Constructing a Web-Server with Patterns at ADC 2004
Tutorial on Constructing a Web-Server with Patterns at ADC 2004
Tutorial on Constructing a Web-Server with Patterns at ADC 2004
Tutorial on Constructing a Web-Server with Patterns at ADC 2004
Tutorial on Constructing a Web-Server with Patterns at ADC 2004
Tutorial on Constructing a Web-Server with Patterns at ADC 2004
Tutorial on Constructing a Web-Server with Patterns at ADC 2004
Tutorial on Constructing a Web-Server with Patterns at ADC 2004
Tutorial on Constructing a Web-Server with Patterns at ADC 2004
Tutorial on Constructing a Web-Server with Patterns at ADC 2004
Tutorial on Constructing a Web-Server with Patterns at ADC 2004
Tutorial on Constructing a Web-Server with Patterns at ADC 2004
Tutorial on Constructing a Web-Server with Patterns at ADC 2004
Tutorial on Constructing a Web-Server with Patterns at ADC 2004
Tutorial on Constructing a Web-Server with Patterns at ADC 2004
Tutorial on Constructing a Web-Server with Patterns at ADC 2004
Upcoming SlideShare
Loading in …5
×

Tutorial on Constructing a Web-Server with Patterns at ADC 2004

1,598 views

Published on

Published in: Economy & Finance, Technology
0 Comments
2 Likes
Statistics
Notes
  • Be the first to comment

No Downloads
Views
Total views
1,598
On SlideShare
0
From Embeds
0
Number of Embeds
23
Actions
Shares
0
Downloads
55
Comments
0
Likes
2
Embeds 0
No embeds

No notes for slide

Tutorial on Constructing a Web-Server with Patterns at ADC 2004

  1. 1. Advanced Developers Conference 10.-11. Oktober 2004 Bemerkungen Pra 03 Constructing a Web- Servers with Patterns Michael Stal Siemens Corporate Technology Bemerkungen Michael Stal – Aufbau eines Web- 1 Servers mit Hilfe von Patterns Case Study Bemerkungen A High-Performance Web Server Dein Name – Dein Vortragstitel Pra 01 - S. 1
  2. 2. Advanced Developers Conference 10.-11. Oktober 2004 Bemerkungen Web Server: The Domain Web Servers provide content and content delivery services to internet users. Bemerkungen Web Server: Key Challenges Different end user needs and traffic workloads require configurable web server architectures regarding the following aspects: Concurrency models: thread per request,Bemerkungen thread pool, ... Event demultiplexing models: synchronous or asynchronous File caching models: least-recently used (LRU), least-frequently used (LFU), ... Content delivery protocols: HTTP/1.0, HTTP/1.1, HTTP-NG Operating system: UNIX, Win32, ... Dein Name – Dein Vortragstitel Pra 01 - S. 2
  3. 3. Advanced Developers Conference 10.-11. Oktober 2004 Bemerkungen Event Demultiplexing (I) A Web server must demultiplex and process multiple types of event, such as CONNECT and HTTP GET requests. To be adaptable towards different usage scenarios, its concrete event demultiplexing and dispatching architecture should: Support changing the event demultiplexing and dispatching code independently of event processing code. Allow the integration of new or improved versions of the event processing services. Support a high throughput. Be simple to use. Bemerkungen Event Demultiplexing (II) Separate event demultiplexing and dispatching from event processing via Reactor: Event handlers (HTTP_Handler) represent the web server‘s services for dispatches processing events that can occur on an * Event_ Bemerkungen Reactor Handler associated event source. maintains owns Handles (Handle) represent event * * sources whose events must be select() Handle notifies processed. An event demultiplexer (select()) HTTP_ HTTP_ Handler 1 Handler 2 discovers and demultiplexes events that occur on handles. A reactor (Reactor) provides the web server‘s event loop and dispatches events that occurred on Handles to their associated HTTP_Handler. Dein Name – Dein Vortragstitel Pra 01 - S. 3
  4. 4. Advanced Developers Conference 10.-11. Oktober 2004 Bemerkungen Reactor: Problem Reactor (POSA2) Clients Problem: Event-driven applications must be prepared to receive multiple service requests simultaneously, but to simplify programming, Logging these requests should be processed serially. How Records This is a logging This is a record can we provide such an infrastructure so that: logging record This is a logging record Event an application does not block on any single event Sources source and exclude other event sources from being serviced. Logging Server application developers are shielded from low-level event detection, de-multiplexing, and dispatching mechanisms. an application is extensible with new event handling components. Bemerkungen a high throughput can be achieved. Output Media Reactor: Structure Solution Structure: Separate event dispatches * demultiplexing and dispatching from event Reactor Event Handler processing. handle_event() register() maintains get_handle() unregister() handle_events() The OS provides mechanisms to represent owns event sources (Handles) and to detect and * Bemerkungen Concrete demultiplex events that occur on these event Handle Event Handler * sources (Event Demultiplexers like Event Demuxer select()). void handle_event(Event e) { notifies switch (e) { A Reactor encapsulates the OS event select() case READ_EVENT: // … case WRITE_EVENT: // … demultiplexing mechanisms and provides // … } } functionality to dispatch events to application void handle_events() { // Listen for events to occur. services. result = select(…); // Dispatch event handler. Event Handlers provide functionality to process for (HANDLE h = 0; h < max_Handle; ++h) { if (FD_ISSET (&read_fds, h) certain types of event that occur on a certain handler_table[h].event_handler-> handle_event(READ_EVENT); event source. They register with the reactor to // Same for WRITE and EXCEPT events. } } get dispatched when the respective events occur on their event source. Dein Name – Dein Vortragstitel Pra 01 - S. 4
  5. 5. Advanced Developers Conference 10.-11. Oktober 2004 Bemerkungen Reactor: Dynamics Solution Dynamics: Dispatch an event handler whenever an event occurs on its handle for Reactor Handler 1 Handler 2 which it has registered. register(handle, events) The Concrete Event Handlers register their register(handle, events) Handle and all events of interest with the Reactor. handle_events The application’s main event loop calls the select Reactor to listen for events to occur on all registered Handles. Once one or more events occurred on the handle_event(event) Handles, the Reactor serially dispatches their Event Handlers to process the occurred events, if the Handlers had registered for them.Bemerkungen Reactor: Consequences Benefits Separation of concerns: event de-multiplexing and dispatching infrastructure is separated from application- specific event processing. Reusability: the event de-multiplexing and dispatching Bemerkungen infrastructure is a reusable component. Extensibility: new or improved event handlers can be added easily. Ease of use: a Reactor provides a simple, serial event handling architecture. Liabilities Restricted applicability: requires appropriate OS support. Non-pre-emptive: in single-threaded applications, long running event handlers can prevent the processing of other events. Dein Name – Dein Vortragstitel Pra 01 - S. 5
  6. 6. Advanced Developers Conference 10.-11. Oktober 2004 Bemerkungen Reactor: Example TAO: The high-performance, real-time CORBA ORB TAO, The ACE ORB, uses a multi-threaded Reactor design as its central server-side ORB core event handling infrastructure. Bemerkungen Reactor Reactor: Known Uses Object Request Brokers: The ACE ORB (TAO) provides Reactor-based event handling infrastructures. GUI infrastructures: MFC and Win Forms provide Reactor-based main Bemerkungen event loops. ACE: The open source ADAPTIVE Communication Environment provides several reusable Reactor frameworks for different types of event demultiplexers, such as WaitForMultipleObjects() and select(), and concurrency models, such as Leader/Followers. Dein Name – Dein Vortragstitel Pra 01 - S. 6
  7. 7. Advanced Developers Conference 10.-11. Oktober 2004 Connection Establishment Bemerkungen (I) The two key activities performed by a connect connect web server are accepting client connection requests and processing connect subsequent HTTP requests. connect To provide a high throughput and quality of service to clients, processing a particular HTTP request must not prevent the web connect server from accepting new client connect connection requests. To support the configuration of the web get server towards different environments and get usage scenarios, it should be possible to modify connection establishment code independently of HTTP request processing Bemerkungen code. Connection Establishment (II) Separate the establishment of connections from processing events via Acceptor- Connector: dispatches * Event_ Reactor Acceptors (HTTP_Acceptor) Bemerkungen Handler maintains owns listen for incoming client * * connection request and select() Handle notifies create/initialize service handlers to process subsequent HTTP HTTP_ HTTP_ requests. Acceptor Handler Service handlers (HTTP_Handler) are created by an acceptor to process a specific client‘s HTTP requests. Dein Name – Dein Vortragstitel Pra 01 - S. 7
  8. 8. Advanced Developers Conference 10.-11. Oktober 2004 Acceptor-Connector: Bemerkungen Problem Acceptor-Connector (POSA2) Clients Problem: In networked systems, components must first connect to one another before they can interact. However: 2: Send 1: Establish Logging Connection in many systems components can act both as Record This is a clients that initiate a connection to a remote logging record component or as servers that accept connection requests from remote clients. the code for connection establishment is largely Logging Server independent of service processing code and can also alter independently. if connection establishment code is interwoven with service processing code, components cannot handle new connection requests while they are processing service requests. Bemerkungen Output Media Acceptor-Connector: Structure Solution Structure: Separate Connector Service Handler Acceptor connection establishment from connect() handle_event() accept() service processing. Service Handlers implement the components that want to interact. Concrete Concrete Concrete Connector Service Handler Acceptor Bemerkungen Connectors actively establish new connections on behalf of a Service Handler to a remote Acceptor. activates creates and/or activates Acceptors passively accept connection requests from remote void connect(Service_Handler *h) { void accept() { Connectors and initialize a Service // Establish connection for // Create new Service Handler. // Service Handler h. Service_Handler *h = new …; Handler to service the connection. if (IPC_mechanism.connect(*h)) // Activate Handler, e.g., // Establish a connection // to register // between the client and Note: both synchronous and //with a Reactor. // the newly created activate(h) // Service Handler. asynchronous connection else IPC_mechanism.accept(h); // Error handling. establishment can be supported. } // Activate Handler, e.g., to // register with a Reactor. activate(h); } Dein Name – Dein Vortragstitel Pra 01 - S. 8
  9. 9. Advanced Developers Conference 10.-11. Oktober 2004 Acceptor-Connector: Bemerkungen Dynamics Solution Dynamics: Let Connector and Acceptor establish a connection Handler 1 Acceptor Connector and pass them on to interacting Service Handlers. A Concrete Service Handler asks a connect(this) Concrete Connector to establish a accept connection to a specific remote Handler 2 activate Concrete Service Handler. The Connector sends a connection interact request to a Concrete Acceptor residing on the respective server. Connector and Acceptor establish the connection and pass them on to ‘their’ Concrete Service Handlers, which then interact. Bemerkungen Acceptor-Connector: Consequences Benefits Separation of concerns: connection establishment is separated from application-specific service processing. Reusability: connectors and acceptors are reusable Bemerkungen components. Efficiency: while service handlers still interact, connectors and acceptors can already establish a new connection. Liabilities Complexity: complex infrastructure and complex implementation for the asynchronous connection establishment. Dein Name – Dein Vortragstitel Pra 01 - S. 9
  10. 10. Advanced Developers Conference 10.-11. Oktober 2004 Acceptor-Connector: Bemerkungen Example Call center applications, such as the Ericsson EOS Call Center Management System or Siemens FlexRouting, use Acceptor-Connector configurations to establish connections actively with passive supervisors (or agents). Public Network Bemerkungen Acceptor-Connector: Known Uses Web Browsers: Internet Explorer, Netscape to connect to servers associated with images embedded in html pages. Object Request Brokers: The ACE ORB (TAO) and Orbix 2000 to establish connections to ORB services. Bemerkungen ACE: provides a reusable Acceptor-Connector framework Call Center Management Systems: Ericsson, Siemens to establish connections to supervisors. Dein Name – Dein Vortragstitel Pra 01 - S. 10
  11. 11. Advanced Developers Conference 10.-11. Oktober 2004 Bemerkungen Concurrency (I) A web server must serve multiple clients simultaneously and at a high- quality of service. Multi-threaded, concurrent event processing is a typical response to this requirement. Yet: Thread management overhead should be minimized to not degrade performance unnecessarily. Resource consumption should be predictable to avoid server saturation. Throughput is important. All events are therefore of identical priority, they are processed in the order of their arrival.Bemerkungen Concurrency (II) Let multiple Leader/Followers service threads share a common set of event sources by taking turns discovering demultiplexing, dispatching, and processing Thread_ shares Pool coordinates events: Bemerkungen (de)activates A thread pool (Thread_Pool) * Event_ coordinates a group of event handler Reactor Handler threads to share a common set of event maintains owns * * sources to process events. * select() Handle Event handlers (HTTP_Handler, notifies HTTP_Acceptor) join the thread pool to process client HTTP requests. HTTP_ HTTP_ Acceptor Handler A Reactor (Reactor) maintains the set of shared event sources. Handles (Handle) represent the set of event sources shared by the event handler threads. Dein Name – Dein Vortragstitel Pra 01 - S. 11
  12. 12. Advanced Developers Conference 10.-11. Oktober 2004 Leader/Followers: Bemerkungen Problem Leader/Followers (POSA2) Clients Problem: An event-driven application may use multi-threading to serve multiple client requests simultaneously. However: Concurrency overhead, such as thread-creation, context switching, thread coordination, should not outweigh the benefits of multi-threading. Resource consumption should be predictable to avoid saturation of the event-driven Logging Server application. Some concurrent application also trade general throughput and performance over scheduling and prioritizing. Requests are structured, repetitive, require immediate response, and can be served via Bemerkungen short, atomic, and isolated processing actions. Output Media Leader/Followers: Structure Solution Structure: Introduce a thread demultiplexes Thread Pool Event Handler * pool in which multiple service instances join() handle_event() share a common event source. uses leader() Events arrive on a Handle Set shared by Concrete all threads. Event Handler Handle Set Bemerkungen Event Handler threads implement application services: follower threads • A Leader Thread gets exclusive access to processing Event threads the Handle Set, and blocks until an event Handler Event arrives. Handler • Follower Threads queue up behind the Event Event leader and wait until it is their turn to be Handler Handler the leader. • Processing Threads are processing an Event Event Handler Handler event they received when being the leader. Handle Set A Thread Pool coordinates the Event leader thread events Handler threads. Dein Name – Dein Vortragstitel Pra 01 - S. 12
  13. 13. Advanced Developers Conference 10.-11. Oktober 2004 Leader/Followers: Bemerkungen Dynamics Solution Dynamics: Let the Event follower threads Handler threads take turns on the shared Handle Set. processing Event threads All threads are spawned. One thread obtains Handler Event access to the Handle Set and becomes the 6 Handler Leader thread (1), all other threads become Followers. An event occurs on the Handle Set and is Event Event received by the Leader thread (2). Handler Handler promote The Leader thread changes its role to a leader Processing thread and processes the request 5 (3), the Thread Pool promotes one Follower 4 Event Event to become the new Leader (4). Handler Handler While the event is processed (5), steps (2) - 3 1 (4) recur. Handle When the event processing finished the Set 2 Processing thread changes its role to a Bemerkungen leader Follower and waits until it becomes the new thread events Leader again (6). Leader/Followers: Consequences Benefits Simple thread management: threads coordinate themselves via the pool; all threads are spawned at system start-up. Bemerkungen Predictable resource consumption: the thread pool is of fixed size Performance: One of the fastest—if not the fastest— concurrency architecture. Liabilities Most suitable for applications with a small set of atomic services. Only suitable for systems whose services have a small memory footprint. No scheduling / priority handling possible. Dein Name – Dein Vortragstitel Pra 01 - S. 13
  14. 14. Advanced Developers Conference 10.-11. Oktober 2004 Leader/Followers: Bemerkungen Example On-Line Transaction Processing (OLTP) Systems, such as for travel agencies, financial services, or broker information, often use the a Leader/Followers concurrency architecture to perform high- volume transaction processing on backend database servers. Bemerkungen Leader/Followers: Known Uses Object Request Brokers: The ACE ORB (TAO) and to handle network events. Application Servers: Application Server to handle network events. Bemerkungen Transaction Monitors: Tuxedo, MTS Transaction Service to process transactions. TAO Features • Open-source • 500+ classes • 500,000+ lines of C++ • ACE/patterns-based • 30+ person-years of effort • Ported to UNIX, Win32, MVS, and many RT & embedded OSs (e.g., VxWorks, LynxOS, Chorus, QNX) Dein Name – Dein Vortragstitel Pra 01 - S. 14
  15. 15. Advanced Developers Conference 10.-11. Oktober 2004 Concurrency Coordination Bemerkungen (I) To avoid concurrency hazards like race conditions, the access sequence of HTTP Processing Threads threads to shared web server HTTP_ HTTP_ components must be coordinated. HTTP_ HTTP_ Handler Handler HTTP_ HTTP_ Handler Handler Handler Handler Some of these shared components—such as the Thread_Pool—are relatively small-sized Thread_Pool objects with a fairly simple, straight-forward logic. Reactor It is crucial that the Thread_Pool executes efficiently—it is the heart of the web servers The thread pool Is shared by the event handling infrastructure. Therefore, the HTTP_Handlers thread coordination mechanism should be To get access to The web server‘s efficient. Event sources. Expensive thread coordination overhead Bemerkungen should be avoided. Concurrency Coordination (II) Coordinate the access to the Thread_Pool by implementing it as Thread_ a Monitor Object: shares Pool dispatches join() The thread pool (Thread_Pool) is a leader() * Bemerkungen monitor object. (de) Event_ Reactor activates The thread pool‘s services (join(), Handler maintains owns Thread_Pool::join() { leader()) are synchronized methods. // Acquire mutex lock automatically. * * Guard<Thread_Mutex> guard (mutex_); * select() Handle The tread pool implementation uses a // run the leader, follower, processor loop. notifies for (;;) { // for ever ... // We have a leader, so sleep ... monitor lock (mutex_) and a condition while (leader_thread != NO_LEADER) condition_.wait(timeout); variable (condition_) to synchronize HTTP_ HTTP_ // Allow other threads to join the pool. Acceptor Handler guard.release(); the access to its services transparently // We are the leader, so access the // event sources. for the HTTP processing threads reactor_->handle_events(); (HTTP_Acceptor , HTTP_Handler). // Reenter monitor to serialize the test. guard.acquire(); } } Dein Name – Dein Vortragstitel Pra 01 - S. 15
  16. 16. Advanced Developers Conference 10.-11. Oktober 2004 Bemerkungen Monitor Object: Problem Monitor Object (POSA2) Problem: Concurrent access to ‘small’ A Call Processing concurrent objects such as a queues or System stacks should be as simple as possible: Synchronization should be easy to implement. +49/89/909090 Threading and synchronization overhead should be minimized or, even better, +49/89/232323 A Call avoided. Processing +49/89/111222 Queue Yet clients should not notice that the object +49/89/999999 is shared. +49/89/987654 +49/89/303030 Bemerkungen Monitor Object: Structure Solution Structure: Synchronize Monitor Object an object’s methods so that only sync_method1() one method can execute at any sync_method2() one time: uses uses 1..* A Monitor Object is an object Monitor Lock Monitor Cond. Bemerkungen multiple threads. shared among acquire() wait() release() notify() Synchronized Methods implement thread-safe functions of the Monitor Object. void sync_method1() { lock.acquire(); // Acquire monitor lock. One or more Monitor Conditions void sync_method2() { ... // Start processing. lock.acquire(); allow the Synchronized Methods // Suspend thread on a monitor condition ... // Start processing. // if immediate progress is impossible. to schedule their execution. if (progress_impossible) if (progress_impossible) condition_1.wait(); condition_2.wait(); A Monitor Lock ensures a ... // Resume processing. ... // Resume processing. serialized access to a Monitor // Notify waiting threads that can condition_1.notify(); Object. // potentially resume their processing // because we are done. lock.release(); condition_2.notify(); } lock.release(); // Release monitor lock. } Dein Name – Dein Vortragstitel Pra 01 - S. 16
  17. 17. Advanced Developers Conference 10.-11. Oktober 2004 Bemerkungen Monitor Object: Dynamics Solution Dynamics: Let the Monitor Object schedule its own method Client Client Monitor Monitor Monitor execution sequence. Thread1 Thread2 Object Lock Cond. A Client Thread invokes a Synchronized method acquire Method. The method acquires the Monitor Lock and starts executing. wait automatic At some point, the method cannot proceed, automatic release suspend therefore it suspends itself on the Monitor Condition, which automatically releases the acquire method lock and puts the calling thread to sleep. Another thread can execute a Synchronized notify Method on the monitor object. Before terminating, this method notifies the Monitor Condition on which the first thread is waiting. release If the Monitor Condition evaluates to true, it automatic resumption automatic automatically re-acquires the Monitor Lock acquisition and resumes the suspended thread as well as release the suspended Synchronized Method. Bemerkungen Monitor Object: Consequences Benefits Simple yet effective: Simplification of concurrency control; simplification of scheduling method execution. Bemerkungen Liabilities Limited scalability: clients can block. Hard to extend: functionality and synchronization logic are tightly coupled. Nested Monitor Lockout Problem. Dein Name – Dein Vortragstitel Pra 01 - S. 17
  18. 18. Advanced Developers Conference 10.-11. Oktober 2004 Bemerkungen Monitor Object: Example class Message_Queue { Message queues are often public: enum { MAX_MESSAGES = /* ... */; }; implemented as Monitor Message_Queue (size_t max_messages = MAX_MESSAGES); /* synchronized */ void put (const Message &msg); /* synchronized */ Message get (); Objects to ensure their thread- /* synchronized */ bool empty () const; /* synchronized */ bool full () const; safe operation. private: void put_i (const Message &msg); Message get_i (); bool empty_i () const; bool full_i () const; bool Message_Queue::empty () const { Guard<Thread_Mutex> guard (monitor_lock_); size_t message_count_; return empty_i (); size_t max_messages_; } mutable Thread_Mutex monitor_lock_; Thread_Condition not_empty_; bool Message_Queue::full () const { Thread_Condition not_full_; Guard<Thread_Mutex> guard (monitor_lock_); } return full_i (); } void Message_Queue::put (const Message &msg) { Guard<Thread_Mutex> guard (monitor_lock_); while (full_i ()) not_full.wait (); put_i (msg); not_empty.notify (); } Message Message_Queue::get () { Guard<Thread_Mutex> guard (monitor_lock_); while (empty_i ()) not_empty.wait (); Bemerkungen Message m = get_i (); not_full.notify (); return m; } Monitor Object: Known Uses ADAPTIVE Communication Environment: ACE provides a communication gateway application that uses Monitor Objects to improve performance on multi-processors. Bemerkungen .NET, Java: the main synchronization mechanism in .NET and Java is based on Monitors. Dein Name – Dein Vortragstitel Pra 01 - S. 18
  19. 19. Advanced Developers Conference 10.-11. Oktober 2004 Efficient Content Access Bemerkungen (I) To achieve a high throughput and a good quality of service, a web server must access URLs requested by clients efficiently. Retrieving the URLs from the file system for every access to them introduces performance penalties, however: Some URLs are more frequently accessed than others. Individual clients often return to an URL they already visited before. Bemerkungen Efficient Content Access (II) Virtual_ Introduce a virtual file system to Filesystem have the content of frequently accessed URLs readily accessible via Caching: Thread_ A cache (Virtual_Filesystem) Bemerkungen shares Pool dispatches join() keeps URL content in memory once leader() * it got accessed and loaded from the (de) Event_ Reactor activates file system for the first time. For Handler maintains owns subsequent accesses, this content is * * * readily available select() Handle notifies HTTP_Handlers first check the HTTP_ HTTP_ cache for URL availability before Acceptor Handler they load it from the file system. Dein Name – Dein Vortragstitel Pra 01 - S. 19
  20. 20. Advanced Developers Conference 10.-11. Oktober 2004 Bemerkungen Caching: Problem Caching (POSA3) Clients Problem: Repetitious acquisition, initialization, 2: Send Logging 1: Establish and release of resources Record Connection 4: Send Logging causes unnecessary 3: Establish This is a logging Record record Connection performance overhead: 6: Send Logging 5: Establish Record Connection The costs of acquisition, Expensive, initialization, and release of Logging Server if we must create the frequently used resources connection should be minimized. each time! Access to the resources should be simple. Bemerkungen Output Media Caching: Structure Solution Structure: Instead of releasing a resource after its usage, temporarily store it in an in-memory buffer: Cache Client Resources represent entities that Bemerkungen acquire() application functionality uses to release() execute its business logic, such as maintains threads, network connections, file * handles, memory, etc. Resource A Cache keeps currently unused resources of a specific type readily available for subsequent use. Clients use the Resources maintained by the Cache to execute their own functionality. Dein Name – Dein Vortragstitel Pra 01 - S. 20
  21. 21. Advanced Developers Conference 10.-11. Oktober 2004 Bemerkungen Caching: Dynamics Solution Dynamics: Create resources once and re-cycle them often: Client Cache A Client requests a Resource from the Cache. create acquire The Cache checks if the Resource is available Resource and creates one, if not Resource The Client uses the Resource. use The Client releases the resource by passing it back to the Cache. release Resource The Cache keeps the Resources for subsequent uses. The Client requests the Resource from the acquire Cache again. Resource The Cache returns the already existing use Resource. The Client ‚re-uses‘ the Resource. Bemerkungen Caching: Consequences Benefits • Performance: Quick access to resources, minimized resource acquisition and release costs. • Predictability: Explicit control of resource usage possible. Bemerkungen Liabilities • Cache maintenance overhead: If the cache is full, its ‚re- organization‘ can cause performance penalties in accessing and using resources. Dein Name – Dein Vortragstitel Pra 01 - S. 21
  22. 22. Advanced Developers Conference 10.-11. Oktober 2004 Bemerkungen Caching: Example Web Browsers: Web Browsers like Netscape and Internet Explorer use a cache to keep local copies of frequently accessed documents. Bemerkungen Caching: Known Uses Web Browsers: Internet Explorer and Netscape cache frequently accessed documents. Web Servers: Apache and Jaws cache frequently requested Bemerkungen documents. Object Request Brokers: The ACE ORB (TAO) caches unused network connections and re-cycles them for new client connections. High-performance applications: Almost every high-performance software uses caches to speed-up performance. Dein Name – Dein Vortragstitel Pra 01 - S. 22
  23. 23. Advanced Developers Conference 10.-11. Oktober 2004 Bemerkungen One Cache Only (I) To achieve predictability regarding resource Virtual_ One file Filesystem consumption, there should system only, please! only be one virtual file system in the web server. Thread_ Pool shares dispatches join() However, OO languages do not leader() * Event_ support an instance-controlled (de) Reactor Handler activates object creation. maintains owns * * * select() Handle notifies HTTP_ HTTP_ Acceptor Handler Bemerkungen One Cache Only (II) Virtual_ Ensure that the web server‘s Filesystem Virtual_Filesystem can be class Virtual_Filesystem { static Virtual_Filesystem *theInstance; instantiated just once by making Virtual_Filesystem () { /* ... */ }; it a Singleton: public: static Virtual_Filesystem *instance() { Thread_ // Create file system, if necessary. if (! theInstance) Bemerkungen A singleton shares Pool dispatches theInstance = new Virtual_Filesystem ; // Return the unique file system instance join() (Virtual_Filesystem) keeps its return theInstance; } leader() } * constructors and destructors private (de) Event_ // Static initialization of the singleton. Reactor activates Virtual_Filesystem * so that only itself can create Handler Virtual_Filesystem ::theInstance = 0; maintains owns instances of itself. * * * select() Handle notifies A class access method ensures that only one instance of a singleton class HTTP_ HTTP_ can be created and offers clients an Acceptor Handler access to this unique instance. Note that we trade safety for flexibility here! Dein Name – Dein Vortragstitel Pra 01 - S. 23

×