Atsuhiro Tanaka

TCP-Migration with Application-Layer Dispatching: A New HTTP Request Distribution Architecture in Locally Distributed Web Server Systems

A cluster-based server system is a developing technology that could achieve high scalability by using several dispatchers, such as layer-4 or layer-7 switches, to appropriately distribute requests from clients. Many recent Web server systems have been developed as cluster systems, but such systems are so complicated that important information for appropriate distribution decisions is in higher layer (i.e., application layer, or layer-7). Although the L7 switches are appliances that can redirect requests by examining the application-layer information, it is difficult to update or modify their distribution algorithms. This paper proposes a novel architecture based on TCP-migration mechanism that provides complete redirection (displacement) of a TCP session from a dispatcher to Web servers. The key idea is physical separation of L7 switch functionality: packet forwarding and request dispatching mechanisms. With NAT mechanism on the L3 switch and sophisticated management of virtual private IP addresses on the cluster servers, the dispatcher is released from relaying or translating both in-bound and out-bound TCP packets after the request has been redirected. This architecture can achieve greater flexibility because the forwarding is performed fast by hardware (i.e., the switch), and the dispatching is managed by software (i.e., application servers). We have designed and implemented this mechanism on Linux 2.4 kernel and evaluated its performance. The experimental results show that the overhead for handling multiple virtual IP addresses is almost negligible. Furthermore, the overhead with TCP-migration by using mini_httpd server and wget client is approximately 1 ms, regardless of the reply size, on 3.06 GHz Xeon machines

Analysis and measurement of the effect of kernel locks in SMP systems

This article reports the use of case studies to evaluate the performance degradation caused by the kernel‐level lock. We define the lock ratio as a ratio of the execution time for critical sections to the total execution time of a parallel program. The kernel‐level lock ratio determines how effective programs work on symmetric multiprocessor (SMP) systems. We have measured the lock ratios and the performance of three types of parallel programs on SMP systems with Linux 2.0: matrix multiplication, parallel make, and WWW server programs. Experimental results show that the higher the lock ratio of parallel programs, the worse their performance becomes. Copyright

Analytical model of inter-node communication under multi-versioned coherence mechanisms

Our goal is to predict the performance of multi-node systems consisting of identical processing nodes based on single node profiles. The performance of multi-node systems significantly depends on the amount of inter-node communication. Therefore, we built an analytical model of the communication amount, i.e., the number of transfers of cached copies, on multi-node systems with coherence mechanisms that support multi-versioning. Multi-versioned mechanisms are assumed because databases are most likely to be the bottleneck and because a typical clustered database has one of these mechanisms. In our model, the number of transfers of copies of a block per write access is expressed as a function of a write ratio, the number of nodes, and the lock down factor which denotes how many versions of copies can exist. To empirically verify our analytical and theoretical model, we compared the number of transfers that predicted by our model and that counted by a toy simulator of multi-versioned mechanisms.

An analytical model of inter-node communication towards performance prediction of multi-node systems

Our goal is to predict the performance of multi-node systems consisting of identical processing nodes based on single node profiles. We clarified how much inter-node communication is caused on n-node systems because the performance significantly depends on the communication amount. However, the amount when business applications such as databases are running is difficult to predict for the following reasons: first, applications are closed and/or complex. Second, workloads vary from system to system. Third, the number of nodes affects the amount. We analytically model the amount under a simple cache coherence mechanism. Our model predicted, with a high degree of accuracy, the number of transfers of cached copies obtained by simulation. Even though our model explains the transfers only under a simple mechanism, the model should explain a fundamental part of those under more complex ones.

Performance modeling of a disk subsystem and its application to performance design of a Web proxy server

The paper presents a performance evaluation method to design the disk subsystem of a Web proxy server. The subsystem has multiple disks on a shared I/O bus. The main feature of this method consists of two basic techniques. One is a parameter estimation method with well-organized measurement procedures on a minimum sized disk subsystem containing one disk attached to one I/O bus. The other is a system performance prediction method based on BCMP queueing network theory. We examine the performance of a target disk subsystem when several parameters (e.g., the disk I/O sizes and the number of disks and I/O requests, etc.) change. For calculating performance metrics with the BCMP queueing network model, we have modified the convolution method to reduce the number of convolutions from the number of connected disks to one. Using the convolution method, the throughputs are calculated for a target disk subsystem with the parameter combinations and are compared to the measurement ones. The comparison shows that prediction errors are between 10% and 20%, which is relatively good precision for an analytical performance model. The effectiveness of the performance evaluation method is examined by designing and developing a Web proxy server.

Interreference interval for purged objects: a new metric for design and analysis of Web caching algorithms

This paper proposes a new metric, called interreference interval for purged objects (II-PO for short) to capture temporal locality in Web references. The metric is used in a partitioned cache model to design and optimize Web caching algorithms. We derive an optimal condition, using the proposed metric, for cache hit ratio in a partitioned cache model. An optimization of the 2Q algorithm is described, as an example, through the obtained optimal partitioning. The case study with the WebPolygraph3 benchmark shows up to 20% relative improvement of the cache hit ratio over the Least Recently Used (LRU) algorithm.

Extension of the working set for modeling spatial locality in program behavior

The paper extends the definition of the working set for modeling spatial locality in program behavior, and it presents theoretical results. One of the theoretical results is that the working set based hit ratio can be given by the time or ensemble averages of the distributions of the interreference interval. We also present, as a theorem, that the average number of unique blocks in the extended working set can be given by the sum of the miss ratios. We derive a mathematical formula to calculate the hit ratio for Markov Chains. A kind of random walk is examined as an example of program behavior. The average number of unique blocks of a given block size in the extended working set is used for comparison with other empirical observations. The comparison had good agreement with our random walk model of program behavior and the empirical observations.

Modelling coherence overhead of multi-versioned caches for random accesses

Our goal is to predict the performance of multi-node systems consisting of identical processing nodes from single node profiles. The performance of multi-node systems that have coherent caches considerably depends on coherence overhead, which is roughly in direct proportion to the number of transfers of cached copies. We analytically model the number of transfers of cached copies of a data block per write access for random accesses where multi-node systems have multi-versioned coherence mechanisms. Our model aims at helping to predict a baseline performance when closed and/or complex business applications are running, such as clustered databases, the algorithmic behaviours of which are practically impossible to analyse and characteristics of which vary from system to system. To empirically verify our analytical model and show how coherence overhead varies in accordance with parameters, we compared the number of transfers that was predicted by our model and that was counted by a toy simulator of multi-versioned mechanisms.