Online Transaction Processing Research Articles

LifeCode: A Deployed Application for Automated Medical Coding

LifeCode is a natural language processing (NLP) and expert system that extracts demographic and clinical information from free-text clinical records. The initial application of LifeCode is for the emergency medicine clinical specialty. An application for diagnostic radiology went into production in October 2000. The LifeCode NLP engine uses a large number of specialist readers whose particular output are combined at various levels to form an integrated picture of the patient's medical condition(s), course of treatment, and disposition. The LifeCode expert system performs the tasks of combining complementary information, deleting redundant information, assessing the level of medical risk and level of service represented in the clinical record, and producing an output that is appropriate for input to an electronic medical record (EMR) system or a hospital information system. Because of the critical nature of the tasks, LifeCode has a unique self-awareness feature that enables it to recognize the limits of its competence and, thus, ask for assistance from a human expert when faced with information that is beyond the bounds of its competence. The LifeCode NLP and expert systems reside in various delivery packages, including online transaction processing, a web browser interface, and an automated speech recognition (ASR) interface.

Code layout optimizations for transaction processing workloads

Commercial applications such as databases and Web servers constitute the most important market segment for high-performance servers. Among these applications, on-line transaction processing (OLTP) workloads provide a challenging set of requirements for system designs since they often exhibit inefficient executions dominated by a large memory stall component. This behavior arises from large instruction and data footprints and high communication miss rates. A number of recent studies have characterized the behavior of commercial workloads and proposed architectural features to improve their performance. However, there has been little research on the impact of software and compiler-level optimizations for improving the behavior of such workloads. This paper provides a detailed study of profile-driven compiler optimizations to improve the code layout in commercial workloads with large instruction footprints. Our compiler algorithms are implemented in the context of Spike, an executable optimizer for the Alpha architecture. Our experiments use the Oracle commercial database engine running an OLTP workload, with results generated using both full system simulations and actual runs on Alpha multiprocessors. Our results show that code layout optimizations can provide a major improvement in the instruction cache behavior, providing a 55% to 65% reduction in the application misses for 64-128K caches. Our analysis shows that this improvement primarily arises from longer sequences of consecutively executed instructions and more reuse of cache lines before they are replaced. We also show that the majority of application instruction misses are caused by self-interference. However, code layout optimizations significantly reduce the amount of self-interference, thus elevating the relative importance of interference with operating system code. Finally, we show that better code layout can also provide substantial improvements in the behavior of other memory system components such as the instruction TLB and the unified second-level cache. The overall performance impact of our code layout optimizations is an improvement of 1.33 times in the execution time of our workload.

Nonvolatile method of semiconductor disk device for the memory database recovery

AbstractTo accelerate database processing, advanced intelligent networks and on‐line transaction processing systems employ memory databases in which all databases reside in main memory. Nonvolatile methods for the semiconductor disk devices backing up the memory databases have been proposed for these systems. Specifically, the methods adopted were a nonvolatile method using directly connected batteries and a method to transfer the contents of the semiconductor disk device to a magnetic disk drive which is a nonvolatile medium. An examination of the required nonvolatile time and the database capacity clearly demonstrated the application ranges of these two techniques by evaluating the battery capacity and the amount of hardware. Consequently, for a database capacity from 512 MB to 2 GB, the required nonvolatile time is about 10 hours. In the semiconductor disk device for an advanced intelligent network, the nonvolatile method using directly connected batteries was shown to be effective. To effectively maintain the batteries, a method to automatically decide whether to replace the batteries was proposed. Finally, the prototype battery structure based on these results and the structure for a service control node in the advanced intelligent network incorporating this battery structure were illustrated. © 2001 Scripta Technica, Electron Comm Jpn Pt 1, 84(9): 42–53, 2001

I/O reference behavior of production database workloads and the TPC benchmarks—an analysis at the logical level

As improvements in processor performance continue to far outpace improvements in storage performance, I/O is increasingly the bottleneck in computer systems, especially in large database systems that manage huge amoungs of data. The key to achieving good I/O performance is to thoroughly understand its characteristics. In this article we present a comprehensive analysis of the logical I/O reference behavior of the peak productiondatabase workloads from ten of the world's largest corporations. In particular, we focus on how these workloads respond to different techniques for caching, prefetching, and write buffering. Our findings include several broadly applicable rules of thumb that describe how effective the various I/O optimization techniques are for the production workloads. For instance, our results indicate that the buffer pool miss ratio tends to be related to the ratio of buffer pool size to data size by an inverse square root rule. A similar fourth root rule relates the write miss ratio and the ration of buffer pool size to data size. In addition, we characterize the reference characteristics of workloads similar to the Transaction Processing Performance Council (TPC) benchmarks C (TPC-C) and D(TPC-D), which are de facto standard performance measures for online transaction processing (OLTP) systems and decision support systems (DSS), respectively. Since benchmarks such as TPC-C and TPC-D can only be used effectively if their strengths and limitations are understood, a major focus of our analysis is to identify aspects of the benchmarks that stress the system differently than the production workloads. We discover that for the most part, the reference behavior of TPC-C and TPC-D fall within the range of behavior exhibited by the production workloads. However, there are some noteworthy exceptions that affect well-known I/O optimization techniques such as caching (LRU is further from the optimal for TPC-C, while there is little sharing of pages between transactions for TPC-D), prefetching (TPC-C exhibits no significant sequentiality), and write buffering (write buffering is lees effective for the TPC benchmarks). While the two TPC benchmarks generally complement one another in reflecting the characteristics of the production workloads, there remain aspects of the real workloads that are not represented by either of the benchmarks.

Characteristics of production database workloads and the TPC benchmarks

There has been very little empirical analysis of any real production database workloads. Although the Transaction Processing Performance Council benchmarks C (TPC-C™) and D (TPC-D™) have become the standard benchmarks for on-line transaction processing and decision support systems, respectively, there has not been any major effort to systematically analyze their workload characteristics, especially in relation to those of real production database workloads. In this paper, we examine the characteristics of the production database workloads of ten of the world's largest corporations, and we also compare them to TPC-C and TPC-D. We find that the production workloads exhibit a wide range of behavior. In general, the two TPC benchmarks complement one another in reflecting the characteristics of the production workloads, but some aspects of real workloads are still not represented by either of the benchmarks. Specifically, our analysis suggests that the TPC benchmarks tend to exercise the following aspects of the system differently than the production workloads: concurrency control mechanism, workload-adaptive techniques, scheduling and resource allocation policies, and I/O optimizations for temporary and index files. We also re-examine Amdahl's rule of thumb for a typical data processing system and discover that both the TPC benchmarks and the production workloads generate on the order of 0.5 to 1.0 bit of logical I/O per instruction, surprisingly close to the much earlier figure.

Seven steps to optimizing data warehouse performance

Most operational systems store data in a normalized model in which certain rules eliminate redundancy and simplify data relationships. While beneficial for the online transaction processing workload, this model can inhibit those same OLTP databases from running analytical queries effectively. Because the analytical systems did not need to support the OLTP workload, many developers began preplanning for the answer sets. Preplanning, however, created problems in four areas: creating summary tables of preaggregated data, placing indexes in the system to eliminate scanning large data volumes, putting data into one table instead of having tables that join together, and storing the data in sorted order. All these activities require prior knowledge of the analysis and reports being requested. Unfortunately, most data warehouse implementations ignore the longer-term goals of analysis and flexibility in the rush to provide initial value. Taking time to consider the project's real purpose, then building a correct foundation for it, can assure a better future for the data warehouse. To meet user demands for more timely and flexible analysis, companies can use a step-by-step approach to move from maintaining detailed information to using summary-level data.

The Journey Out and In

The automation of library processes involves by its very nature the collection of information about patrons and the materials they use. As well, because online transaction processing (OLTP) depends upon the identification of workstations and time-stamping of transactions, information about staff productivity is also present in the system. While such information is of use in collections management and for error detection and correction, its collection raises security concerns. As well, beginning in the 1980s, local library automation systems came to be linked within consortia and eventually, across the Internet. This retrospective look at local library automation summarizes developments in connectivity occurring during the 1980s and 1990s, and suggests additional concerns associated with the open computing environment of the present day.

Piranha

The microprocessor industry is currently struggling with higher development costs and longer design times that arise from exceedingly complex processors that are pushing the limits of instruction-level parallelism. Meanwhile, such designs are especially ill suited for important commercial applications, such as on-line transaction processing (OLTP), which suffer from large memory stall times and exhibit little instruction-level parallelism. Given that commercial applications constitute by far the most important market for high-performance servers, the above trends emphasize the need to consider alternative processor designs that specifically target such workloads. The abundance of explicit thread-level parallelism in commercial workloads, along with advances in semiconductor integration density, identify chip multiprocessing (CMP) as potentially the most promising approach for designing processors targeted at commercial servers. This paper describes the Piranha system, a research prototype being developed at Compaq that aggressively exploits chip multi-processing by integrating eight simple Alpha processor cores along with a two-level cache hierarchy onto a single chip. Piranha also integrates further on-chip functionality to allow for scalable multiprocessor configurations to be built in a glueless and modular fashion. The use of simple processor cores combined with an industry-standard ASIC design methodology allow us to complete our prototype within a short time-frame, with a team size and investment that are an order of magnitude smaller than that of a commercial microprocessor. Our detailed simulation results show that while each Piranha processor core is substantially slower than an aggressive next-generation processor, the integration of eight cores onto a single chip allows Piranha to outperform next-generation processors by up to 2.9 times (on a per chip basis) on important workloads such as OLTP. This performance advantage can approach a factor of five by using full-custom instead of ASIC logic. In addition to exploiting chip multiprocessing, the Piranha prototype incorporates several other unique design choices including a shared second-level cache with no inclusion, a highly optimized cache coherence protocol, and a novel I/O architecture.

Identifying The Demand For Features: An Application To Mainframe Computers

This paper examines the mainframe computer market from 1985–1991 and attempts to identify the types of buyers that demand particular computer features, such as speed and memory. To identify these buyers, demand for computer characteristics is estimated using a demand model based on Rosen (1974). Through these demand estimates we are able to show that the advent of on-line transactions processing was pushing the demand for computer speed and memory to some extent. However, beyond this specialized application, only a few industries seemed to be demanding the newest technology, while the majority of buyers continued to buy small mainframes throughout the sample period.

Application of middleware in the three tier client/server database design methodology

With the popularity of personal computers and powerful workstations, today’s users are no longer satisfied with the traditional data processing. They demand eagerly to putting up graphics on existing applications, putting a lot of pressure in system re-engineering. The Client/Server architecture is a less risky and less costly approach in adding a Graphical User Interface for users. The developer has to determine data and program logic distribution among client, middleware server, and the top-tier server. Middleware is a kind of software that links programs running on different platforms, transmitting messages and data. It plays an important role in 3-tier architecture. There are two types of middlewares: the first connects client programs to server programs, and the second provides data access connections to heterogeneous data sources. The developer also needs to separate on-line transaction processing, project-oriented data processing, and history data from each other. In view of no existing standard method in developing a middleware server, this paper outlines a methodology to design a 3-tier Client/Server database system. It identifies the role of middleware as temporary storage for better performance and as database gateway for Database Management Systems connectivity. Case studies are used to illustrate the steps.

Modelling And Simulation Of Parallel On-Line Transaction Processing Systems

This paper presents a model and a simulator of parallel computers for on-line transaction processing (OLTP). The authors also present some performance results obtained by the simulator. In OLTP systems that consist of parallel computers, system performance depends on two system configuration factors: the number of hardware components that operate in parallel, and their interconnection scheme. The proposed model and simulator describe these factors. The results obtained from the simulation experiments seem to emphasize the importance of suitable selection of these configuration factors to achieve good performance.

System optimization for OLTP workloads

Major performance enhancements in large commercial systems are best achieved when advances in hardware technology are matched with advances in software technology. This article connects recent AS/400 hardware advances with the corresponding approaches used to tune the system performance for large online transaction processing (OLTP) workloads. We particularly emphasize those tuning efforts that affect the memory system. OLTP workloads are large and complex, stressing many parts of both the software and hardware. These workloads quickly expose software bottlenecks caused by contention on software locks. They also have large working sets, populated with hard-to-predict access patterns that make cache miss rates high. This causes the processor to spend a significant part of its execution time waiting for memory accesses. In multiprocessor systems, compilers alone have minimal effect on cycles spent in storage latency. Other optimizations are needed to affect this portion of the execution time, and many of those require direct involvement of the system software.

What‘s in the Middle?

Enterprise Middleware has the power to help you quickly develop, deploy and manage critical on-line transaction processing and client/server applications to take advantage more easily of new business opportunities and to manage, change or extend your business — but first you need to know what to look for in the increasingly diverse range of technology products. This paper discusses the issues that a programme in BT should consider when selecting middleware products to deploy with BT systems. The paper draws upon the experiences gained within the Client/Server Evolution Laboratory (CSLab), part of in Ipswich Software Engineering Centre's (ISEC's) Systems and Software Strategy Unit, with particular emphasis on the Object Management Group's Common Object Request Broker Architecture (CORBA), Distributed Computing Environment and Java.

A SAFE AND SCALABLE PAYMENT INFRASTRUCTURE FOR TRADE OF ELECTRONIC CONTENT

BARTER (a Backbone ARchitecture for Trade of ElectRonic content) is a payment infrastructure that facilitates digital content trade over an open network. BARTER is designed to operate over a large-scale, global and heterogeneous communication network. The BARTER protocols address two vital requirements, neglected from existing electronic commerce systems: scalability and transactional efficiency. These protocols possess strong properties such as delivery atomicity, agreement validation and the ability to resolve several classes of disputes. BARTER's novelty is twofold: First, BARTER servers are not required to perform expensive cryptographic operations such as commitment verification; commitments are cross-verified by the parties themselves, thus reducing the overhead of online transaction processing by orders of magnitude. Consequently, BARTER can serve as an efficient online/offline clearing infrastructure. Second, BARTER integrates scalability considerations into several system components (the authentication subsystem, the account management subsystem, and the maintenance of global data) that are likely to suffer service degradation in a world-wide setting. In addressing these issues, BARTER takes into account the inherent asynchronous, unreliable, insecure and failure-prone environment assumptions. We contend that by employing service distribution, BARTER is expected to scale well, meeting the demands of a world-wide setting, over which it is intended to operate.

Performance of database workloads on shared-memory systems with out-of-order processors

Database applications such as online transaction processing (OLTP) and decision support systems (DSS) constitute the largest and fastest-growing segment of the market for multiprocessor servers. However, most current system designs have been optimized to perform well on scientific and engineering workloads. Given the radically different behavior of database workloads (especially OLTP), it is important to re-evaluate key system design decisions in the context of this important class of applications.This paper examines the behavior of database workloads on shared-memory multiprocessors with aggressive out-of-order processors, and considers simple optimizations that can provide further performance improvements. Our study is based on detailed simulations of the Oracle commercial database engine. The results show that the combination of out-of-order execution and multiple instruction issue is indeed effective in improving performance of database workloads, providing gains of 1.5 and 2.6 times over an in-order single-issue processor for OLTP and DSS, respectively. In addition, speculative techniques enable optimized implementations of memory consistency models that significantly improve the performance of stricter consistency models, bringing the performance to within 10--15% of the performance of more relaxed models.The second part of our study focuses on the more challenging OLTP workload. We show that an instruction stream buffer is effective in reducing the remaining instruction stalls in OLTP, providing a 17% reduction in execution time (approaching a perfect instruction cache to within 15%). Furthermore, our characterization shows that a large fraction of the data communication misses in OLTP exhibit migratory behavior; our preliminary results show that software prefetch and writeback/flush hints can be used for this data to further reduce execution time by 12%.

Performance of database workloads on shared-memory systems with out-of-order processors

Database applications such as online transaction processing (OLTP) and decision support systems (DSS) constitute the largest and fastest-growing segment of the market for multiprocessor servers. However, most current system designs have been optimized to perform well on scientific and engineering workloads. Given the radically different behavior of database workloads (especially OLTP), it is important to re-evaluate key system design decisions in the context of this important class of applications.This paper examines the behavior of database workloads on shared-memory multiprocessors with aggressive out-of-order processors, and considers simple optimizations that can provide further performance improvements. Our study is based on detailed simulations of the Oracle commercial database engine. The results show that the combination of out-of-order execution and multiple instruction issue is indeed effective in improving performance of database workloads, providing gains of 1.5 and 2.6 times over an in-order single-issue processor for OLTP and DSS, respectively. In addition, speculative techniques enable optimized implementations of memory consistency models that significantly improve the performance of stricter consistency models, bringing the performance to within 10--15% of the performance of more relaxed models.The second part of our study focuses on the more challenging OLTP workload. We show that an instruction stream buffer is effective in reducing the remaining instruction stalls in OLTP, providing a 17% reduction in execution time (approaching a perfect instruction cache to within 15%). Furthermore, our characterization shows that a large fraction of the data communication misses in OLTP exhibit migratory behavior; our preliminary results show that software prefetch and writeback/flush hints can be used for this data to further reduce execution time by 12%.

Performance evaluation of three logging schemes for a shared-nothing database server

The European declarative system (EDS) is a high performance backend database server designed for a range of commercial mainframes. One major application domain of EDS is information processing for business and commercial environments. High performance is achieved by exploiting parallelism using a shared-nothing Computer (up to 256 processors) and by reducing data access latency using large main memory storage (up to 4 Gbytes per PE) to hold the entire database in memory at processing time. Reliability is a crucial design issue for commercial and business information systems. Recovery control facilitates reliability and logging forms an important part of it. In general, logging is costly to implement; it is usually achieved in the expense of reduced system performance. A desirable logging scheme should not overload the database management system resulting in poor system performance. Three logging schemes have been studied for EDS: 1. (a) local discs — adopt a conventional approach by incorporating a local disc on each processor; 2. (b) duplexing — arrange the processors in pairs, one for database operations and one for backup; and 3. (c) cooperative logging similar to duplexing except database and backup operations are performed on a single processor. The performance of these schemes for on-line transaction processing was evaluated and compared using the EDS behavioral simulator. The results of the evaluations are presented in this paper. The results indicate that the cooperative logging scheme performs best amongst the three alternatives, but an EDS server based on this scheme can only achieve 70% of the performance target.

Memory system characterization of commercial workloads

Commercial applications such as databases and Web servers constitute the largest and fastest-growing segment of the market for multiprocessor servers. Ongoing innovations in disk subsystems, along with the ever increasing gap between processor and memory speeds, have elevated memory system design as the critical performance factor for such workloads. However, most current server designs have been optimized to perform well on scientific and engineering workloads, potentially leading to design decisions that are non-ideal for commercial applications. The above problem is exacerbated by the lack of information on the performance requirements of commercial workloads, the lack of available applications for widespread study, and the fact that most representative applications are too large and complex to serve as suitable benchmarks for evaluating trade-offs in the design of processors and servers.This paper presents a detailed performance study of three important classes of commercial workloads: online transaction processing (OLTP), decision support systems (DSS), and Web index search. We use the Oracle commercial database engine for our OLTP and DSS workloads, and the AltaVista search engine for our Web index search workload. This study characterizes the memory system behavior of these workloads through a large number of architectural experiments on Alpha multiprocessors augmented with full system simulations to determine the impact of architectural trends. We also identify a set of simplifications that make these workloads more amenable to monitoring and simulation without affecting representative memory system behavior. We observe that systems optimized for OLTP versus DSS and index search workloads may lead to diverging designs, specifically in the size and speed requirements for off-chip caches.

An analysis of database workload performance on simultaneous multithreaded processors

Simultaneous multithreading (SMT) is an architectural technique in which the processor issues multiple instructions from multiple threads each cycle. While SMT has been shown to be effective on scientific workloads, its performance on database systems is still an open question. In particular, database systems have poor cache performance, and the addition of multithreading has the potential to exacerbate cache conflicts.This paper examines database performance on SMT processors using traces of the Oracle database management system. Our research makes three contributions. First, it characterizes the memory-system behavior of database systems running on-line transaction processing and decision support system workloads. Our data show that while DBMS workloads have large memory footprints, there is substantial data reuse in a small, cacheable "critical" working set. Second, we show that the additional data cache conflicts caused by simultaneous multithreaded instruction scheduling can be nearly eliminated by the proper choice of software-directed policies for virtual-to-physical page mapping and per-process address offsetting. Our results demonstrate that with the best policy choices, D-cache miss rates on an 8-context SMT are roughly equivalent to those on a single-threaded superscalar. Multithreading also leads to better interthread instruction cache sharing, reducing I-cache miss rates by up to 35%. Third, we show that SMT's latency tolerance is highly effective for database applications. For example, using a memory-intensive OLTP workload, an 8-context SMT processor achieves a 3-fold increase in instruction throughput over a single-threaded superscalar with similar resources.

Security in Distributed Computing

Glen Bruce and Rob Dempsey Prentice Hall PTR, Upper Saddle River, NJ, 1997, 456 pp. ISBN 0-13-182908-4, $56.00 This book is well written and organized to cover all aspects of computer security, especially in distributed computing environments. The overall computer security problems in computer systems, computer networks and database systems are explained throughout the book. Furthermore, the computer security problems are covered in balance based on the views and approaches of the business and technology sides. The book is organized with four parts. The introductory part 1 begins with a good overview of the security problems in distributed computing environments. In part 2, the foundations of computer security are discussed. Chapter 3 covers computing security basics by using the trust model which consists of identification, authentication, authorization, confidentiality, integrity, nonrepudiation, and so on. Chapter 4 explains the security architecture model which is based on foundation control and trust models. The following chapter 5 illustrates the foundation model that is based on security policy, security principles, security criteria and standards, and education. Chapter 6 discusses security policies based on corporate principles and business code of conduct. In part 3, all aspects of computer security technologies are covered. Chapter 7 begins with the illustration of what is a trusted network, which is followed by the discussions of System Network Architecture (SNA) and Transmission Control Protocol and Internet Protocol (TCP/IP). Chapter 8 explains network operating systems mostly based on Novell’s NetWare as well as other networking operating systems. Chapter 9 illustrates client/server system and Common Object Request Broker Architecture (CORBA) briefly. The security problems and possible corresponding solutions are explained well in chapters 10 through 12, which are followed by chapter 13 specifying Windows NT security. Chapter 14 explains the security problems and requirements connecting the network to the Internet by using a firewall machine as an example. Chapter 15 illustrates Data Encryption Standard (DES) private key encryption, and RSA public key encryption which are very well to understand. Chapter 16 covers the Distributed Computing Environment (DCE) from the Open Software Foundation (OSF) which provides the fundamental middleware services that allow clients and servers to work in a secure way. The following chapter 17 enhances the discussion of the fundamental aspects of DCE of chapter 16. Chapter 18 extends to the illustration of the security features in distributed database systems. The last chapter in part 2 explains the On-Line Transaction Processing (OLTP) by using available commercial products. In part 4, chapter 20 begins with how to design client-server applications satisfying security issues discussed in the previous chapters. Chapter 21 shows the examples of applying computer security in electronic mail and groupware. The following chapters 22 and 23 discuss how to manage security in the distributed system environments and how to develop a suitable security strategy for organizations. Chapter 24 explains well about all aspects related to auditing in computer systems. The final chapter of this book concludes with describing the security issues in the future. This book is an important reference book for anyone interested in computer security in distributed computing and especially for those beginners in the computer security field. The book is one of the better computer security books that is easy to follow. Haklin Kimm, University of Tennessee