Photo
Advanced Enterprise Middleware

 

Performance, Scalability, and Reliability

Performance, scalability, and reliability are critically important for middleware systems. In many cases, the overhead for a system can be substantially reduced by caching. In order for an application to benefit from caching, it must repeatedly use data which is expensive to calculate or fetch. By caching such data, the application only needs to calculate or fetch the data once. Whenever the data is needed after it has been cached, the application can fetch the data from the cache instead of recalculating it or fetching it from a remote location. Caching can take place at several points within a system. A processor cache might have one or more caches for reducing the latency for accessing data. A database might also have a cache for storing frequently requested data. Caching within Web systems can occur at several different points such as within browsers, servers, and proxies. Browser and proxy caching reduce the latency for fetching remote documents and network utilization; server CPU cycles may also be reduced. Server caching can reduce processing cycles consumed by the server, particularly if the server generates considerable dynamic content which can be cached.

We have used caching to improve the performance of several distributed systems, most notably large-scale commercial Web systems. One of our key contributions has been to reduce the overhead for serving dynamic Web data by caching [USITS'97]. The key problem with caching dynamic data is maintaining consistent caches. One key technique for maintaining consistent caches is Data Update Propagation (DUP) [ToN'04, INFOCOM'99]. DUP maintains dependencies between underlying data such as database tables and cached objects such as Web pages in a graph. When underlying data change, graph traversal algorithms are applied to determine the cached objects affected by the change.

We have also developed other methods for maintaining Web cache consistency. Web caching is promising in reducing latency and increasing scalability of internet-wide services. The effectiveness of web caching is determined to a great extent by the performance of underlying cache consistency protocols. Designing high performance web cache consistency protocols is challenging because of the large scale of the web. A popular web server can have millions of clients. The large number of clients also implies that a significant number of clients cannot be reached by the server at any given time as the probability of partial failures is multiplied with the scale of the system. On the one hand, client polling with short cached object lifetimes is highly scalable and failure-resilient, but incurs a large number of client polls for reads and thus reduces the effectiveness of caching. On the other hand, server invalidation minimizes server accesses for cache revalidation, but can not handle failures well and is not as scalable. We have developed the Volume Lease protocol to maintain Web cache consistency [ToIT'02, WWW10]. Volume Lease amortizes cache revalidation costs over many objects in a volume. Experimental results show that Volume Lease can match the performance of server invalidation and the scalability and failure-resiliency of client polling.

Another key technique for efficiently generating dynamic Web data is to compose Web pages from fragments [ToIT'05, INFOCOM2000]. Fragments typically have different lifetimes. A key advantage to using fragments is that when a fragment changes, the entire Web page doesn't have to be updated; only the fragment needs to be updated. Fragment-based Web publication allows parts of dynamic Web pages to be cached. Caches may dynamically assemble Web pages from fragments; relatively static fragments may be cached remotely while highly dynamic and personalized fragments are fetched from the server. We have demonstrated the effectiveness of fragment-based Web publication at highly accessed Web sites and developed techniques for automatically detecting fragments in Web pages. We have also developed techniques for automatically detecting fragments in Web pages [TKDE'05, WWW2004]; automatic fragment detection makes it much easier to develop Web pages using fragments.

In some systems, it is possible to improve performance by employing caches explicitly managed by the application. We refer to this type of caching as application-level caching. Application-level caching has been critically important for improving middleware systems we have worked on such as the Accessible Business Rules (ABR) (also known as Business Rule Beans, or BRBeans) for IBM's Websphere. ABR is a middleware system which enables application writers to build applications where the time and situation-variable parts of their business logic are externally applied entities known as business rules. The techniques we have used for caching in ABR can be applied to other applications as well. The General-Purpose Software cache (GPS cache) which we used is designed to be plugged into different applications. The GPS cache has also been successfully deployed in a Web server accelerator. The GPS cache has very efficient code for storing data in memory, on disk, or both. It also has optimized support for invalidating objects based on expiration times and for logging cache transactions [IPCCC'99]. The GPS cache, as applied in ABR, stores the results of queries ultimately made to a database. A key problem with caching query results is determining which queries are affected by changes that occur to the database. In order to keep caches current after database updates, we use an enhanced version of data update propagation (DUP). A query result may depend on several attributes, and these dependency relationships are represented by an object dependence graph (ODG). DUP had been previously used to cache dynamic Web data. We made two key innovations to DUP for caching in ABR. When attributes change, we consider the old and new values of the attributes in order to determine how to update the cache. This value-aware update policy is implemented by annotating edges of ODG's with values based on queries. When DUP was used for caching dynamic Web data, an application program was responsible for generating the ODG. The second key innovation we made to DUP for ABR was to automatically generate ODG's from the queries within an ABR application [Middleware 2000].

Papers


Copyright Notices

  • ACM Papers - Copyright © by Association for Computing Machinery, Inc. Permission to make digital or hard copies of part of all of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for profit or commercial advantage. To copy otherwise, to republish, to post of servers, or to redistribute to lists, requires prior specific permission and/or a fee.
  • IEEE Papers - Copyright © by IEEE. Permission to make digital or hard copies of part or all of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for profit. To copy otherwise, to republish, to post of servers, or to redistribute to lists, requires prior specific permission and/or a fee.

More

Questions and/or comments about this work can be directed to Arun Iyengar (email: aruni(at)us(dot)ibm(dot)com), Lou Degenaro (email: degenaro(at)us(dot)ibm(dot)com), Jian Yin (email: jianyin(at)us(dot)ibm(dot)com), or Isabelle Rouvellou (email: rouvellou(at)us(dot)ibm(dot)com).