Lilian Harada

The Impact of Soft Resource Allocation on n-Tier Application Scalability

Good performance and efficiency, in terms of high quality of service and resource utilization for example, are important goals in a cloud environment. Through extensive measurements of an n-tier application benchmark (RUBBoS), we show that overall system performance is surprisingly sensitive to appropriate allocation of soft resources (e.g., server thread pool size). Inappropriate soft resource allocation can quickly degrade overall application performance significantly. Concretely, both under-allocation and over-allocation of thread pool can lead to bottlenecks in other resources because of non-trivial dependencies. We have observed some non-obvious phenomena due to these correlated bottlenecks. For instance, the number of threads in the Apache web server can limit the total useful throughput, causing the CPU utilization of the C-JDBC clustering middleware to decrease as the workload increases. We provide a practical iterative solution approach to this challenge through an algorithmic combination of operational queuing laws and measurement data. Our results show that soft resource allocation plays a central role in the performance scalability of complex systems such as n-tier applications in cloud environments.

Join strategies on KD-tree indexed relations

Join algorithms on KD-tree indexed relations are proposed. The join algorithms are based on a concept called wave. The wave is a set of pages that is the object of joining and that propagates over the relation space in the direction of the join attribute axis. Four basic join algorithms that determine the wave from one of the relations and one algorithm that determines the wave from both relations are proposed. The algorithms are described and extensively analyzed with analytical formulas and simulation results. Then a garbage collection mechanism is introduced that discards the unnecessary data loaded in the main memory and extends the previous basic algorithms with an efficient memory management. It is shown that the proposed algorithms perform the join of very large relations with one scan.<<ETX>>

Order checking in a CPOE using event analyzer

In this paper we present our experience in applying Event Analyzer, a processing engine we have developed to extract patterns from a sequence of events, in the checking of medical orders of a CPOE system. We present some extensions we have implemented in Event Analyzer in order to fulfill the needs of those orders checking, as well as some performance evaluation results. We also outline some problems we are facing now to adapt Event Analyzers pattern detection engine to support streaming orders in an on-line CPOE checking system.

Functional disk system for relational database

The major performance bottle neck in the current computer system is in the low-performance secondary system. The performance of the CPU has increased dramatically so far, about several orders of magnitude improvement has been achieved. On the other hand, that of the disk system has shown little advance since nineteen sixties. The von Neumann bottle neck between the CPU and the secondary storage subsystem has been much more enlarged.

Detection of complex temporal patterns over data streams

A growing number of applications require support for processing data that is in the form of continuous stream rather than finite stored data. For instance, network and traffic management, medical monitoring are some of the new applications that continuously examine a sensor stream in order to detect any undesirable behavior of the monitored system that requires further inspection. In this paper we present a new algorithm to detect undesirable system behaviors that are represented by some complex temporal patterns over data streams. Our algorithm efficiently scans the data stream with a sliding window, and checks the data inside the window from right-to-left to see if they satisfy the pattern predicates. By first preprocessing the complex temporal patterns at compile time, it can exploit the interdependencies between the pattern predicates, and skip unnecessary checks with efficient window slides at run time. It resembles the sliding window process of the Boyer--Moore algorithm, although allowing complex predicates that are beyond the scope of this traditional string search algorithm. Implementation and evaluation of the proposed algorithm shows its efficiency when compared to previously proposed approaches.

Complex Temporal Patterns Detection over Continuous Data Streams

A growing number of applications require support for processing data that is in the form of continuous stream, rather than finite stored data. In this paper we present a new approach for detecting temporal patterns with complex predicates over continuous data stream. Our algorithm efficiently scans the stream with a sliding window, and checks the data inside the window from right-to-left to see if they satisfy the pattern predicates. By first preprocessing the complex temporal patterns at compile time, it can exploit their predicates interdependency, and skip unnecessary checks with efficient window slides at run time. It resembles the sliding window process of the Boyer-Moore algorithm, although allowing complex predicates that are beyond the scope of this traditional string search algorithm. Some preliminary evaluation of our proposed algorithm shows its efficiency when compared to the naive approach.

Pattern Matching over Multi-attribute Data Streams

Recently a growing number of applications monitor the physical world by detecting some patterns and trends of interest. In this paper we present two algorithms that generalize string-matching algorithms for detecting patterns with complex predicates over data streams having multiple categorical and quantitative attributes. Implementation and evaluation of the algorithms show their efficiency when compared to the naive approach.

Performance evaluation of functional disk system with nonuniform data distribution

In this paper, we analyze the performance of a Functional Disk System with Relational database engine (FDS-RII) for a nonuniform data distribution. FDS-RII is a relational storage system, designed to accelerate relational algebraic operations, which employs a hash-based algorithm to process relational operations. Basically, in the hash-based algorithm, a relation is first partitioned into several clusters by a split function. Then each cluster is staged onto the main memory and, further, a hash function is applied to each cluster to perform a relational operation. Thus, the nonuniformity of split and hash functions is considered to be resulting from a nonuniform data distribution on the hash-based algorithm. We clarify the effect of nonuniformity of the hash and split functions on the join performance. It is possible to attenuate the effect of the hash function nonuniformity by increasing the number of processors and processing the buckets in parallel. Furthermore, in order to tackle the nonuniformity of split function, we introduce the Combined Hash Algorithm. This algorithm combines the Grace Hash Algorithm with the Nested Loop Algorithm in order to handle the overflown bucket efficiently. Using the Combined Hash Algorithm, we find that the execution time of the nonuniform data distribution is almost equal to that of the uniform data distribution. Thus we can get sufficiently high performance on FDS-RII also for nonuniformly distributed data.

Event analyzer: a tool for sequential data processing

In this paper we present a tool called Event Analyzer that processes events that compose a sequence. We present the data model in which Event Analyzer is based, as well as its query language that allows the expression of complex patterns to be searched over the sequence of events. The Event Analyzer has been developed and it now integrates the Fujitsu Symfoware e-Business Intelligence Suite Premium.

Managing Non-Volatile Memory in Database Systems

Non-volatile memory (NVM) is a new storage technology that combines the performance and byte addressability of DRAM with the persistence of traditional storage devices like flash (SSD). While these properties make NVM highly promising, it is not yet clear how to best integrate NVM into the storage layer of modern database systems. Two system designs have been proposed. The first is to use NVM exclusively, i.e., to store all data and index structures on it. However, because NVM has a higher latency than DRAM, this design can be less efficient than main-memory database systems. For this reason, the second approach uses a page-based DRAM cache in front of NVM. This approach, however, does not utilize the byte addressability of NVM and, as a result, accessing an uncached tuple on NVM requires retrieving an entire page. In this work, we evaluate these two approaches and compare them with in-memory databases as well as more traditional buffer managers that use main memory as a cache in front of SSDs. This allows us to determine how much performance gain can be expected from NVM. We also propose a lightweight storage manager that simultaneously supports DRAM, NVM, and flash. Our design utilizes the byte addressability of NVM and uses it as an additional caching layer that improves performance without losing the benefits from the even faster DRAM and the large capacities of SSDs.