15475945
Performance prediction of component-based applications
One of the major problems in building large-scale enterprise systems is anticipating the performance of the eventual solution before it has been built. The fundamental software engineering problem becomes more difficult when the systems are built on component technology. This paper investigates the feasibility of providing a practical solution to this problem. An empirical approach is proposed to determine the performance characteristics of component-based applications by benchmarking and profiling. Based on observation, a model is constructed to act as a performance predictor for a class of applications based on the specific component technology. The performance model derived from empirical measures is necessary to make the problem tractable and the results relevant. A case study applies the performance model to an application prototype implemented by two component infrastructures: CORBA and J2EE.
11844078
Customized Benchmark Generation Using MDA
This paper describes an approach for generating customized benchmark applications from a software architecture description using a Model Driven Architecture (MDA) approach. The benchmark generation and performance data capture tool implementation is based on widely used open source MDA frameworks. The business logic of the benchmark application is modeled in UML and generated by taking advantage of the existing generation "cartridges" so that the current component technology can be exploited in the benchmark. This greatly reduces the effort and expertise needed for benchmarking with complex component technology. We have also extended the MDA framework to model and generate a load testing suite and automatic performance measurement infrastructure. The approach complements current model-based performance prediction and analysis methods by generating the benchmark application from the same application architecture that the performance models are derived from. This provides the potential for tightly integrating runtime performance measurement with model-based prediction either for model validation or improving model prediction accuracy. We illustrate the approach using a case study based on EJB component technology.
16328925
An empirical evaluation of architectural alternatives for J2EE and Web services
Component-based technologies such as J2EE and .NET have been widely adopted to develop Web-based applications. With the emerging use of Web services and service-based architectures, such component technologies provide the necessary back-end components to execute application business logic, supporting a variety of architectural alternatives. The combination of component technologies with Web services further extends the set of architecture choices, with each providing different levels of performance. It is therefore important for an architect to understand these performance implications in the early stages of the architecture design. In this paper, we measure and analyze the performance of four alternative architectures using J2EE and Web services. The purpose is to investigate the effects on performance, identify both hardware and software bottlenecks, and analyze the architectural design trade-offs.
18374506
Design-level performance prediction of component-based applications
Server-side component technologies such as Enterprise JavaBeans (EJBs), .NET, and CORBA are commonly used in enterprise applications that have requirements for high performance and scalability. When designing such applications, architects must select suitable component technology platform and application architecture to provide the required performance. This is challenging as no methods or tools exist to predict application performance without building a significant prototype version for subsequent benchmarking. In this paper, we present an approach to predict the performance of component-based server-side applications during the design phase of software development. The approach constructs a quantitative performance model for a proposed application. The model requires inputs from an application-independent performance profile of the underlying component technology platform, and a design description of the application. The results from the model allow the architect to make early decisions between alternative application architectures in terms of their performance and scalability. We demonstrate the method using an EJB application and validate predictions from the model by implementing two different application architectures and measuring their performance on two different implementations of the EJB platform.
16602968
Performance prediction of J2EE applications using messaging protocols
Predicting the performance of component-based applications is difficult due to the complexity of the underlying component technology. This problem is exacerbated when a messaging protocol is introduced to create a loosely coupled software architecture. Messaging uses asynchronous communication, and must address quality of service issues such as message persistence and flow control. In this paper, we present an approach to predicting the performance of Java 2 Enterprise Edition (J2EE) applications using messaging services. The prediction is done during application design, without access to the application implementation. This is achieved by modeling the interactions among J2EE and messaging components using queuing network models, calibrating the performance model with architecture attributes associated with these components, and populating the model parameters using a lightweight, application-independent benchmark. Benchmarking avoids the need for prototype testing in order to obtain the value of model parameters, and thus reduces the performance prediction effort. A case study is carried out to predict the performance of a J2EE application with asynchronous communication. Analysis of the resulting predictions shows the error is within 15%.
3059659
From recursion to iteration: what are the optimizations?
Transforming recursion into iteration eliminates the use of stack frames during program execution. It has been studied extensively. This paper describes a powerful and systematic method, based on incrementalization, for transforming general recursion into iteration: identify an input increment, derive an incremental version under the input increment, and form an iterative computation using the incremental version. Exploiting incrementalization yields iterative computation in a uniform way and also allows additional optimizations to be explored cleanly and applied systematically, in most cases yielding iterative programs that use constant additional space, reducing additional space usage asymptotically, and run much faster. We summarize major optimizations, complexity improvements, and performance measurements.
2056912
Performance and Scalability Measurement of COTS EJB Technology
Enterprise Java Bean (EJB) is the core technology of J2EE platform to provide the foundation for scalable enterprise applications. About 30 product vendors provide implementations of the J2EE/EJB specification. As each of these products is designed and implemented differently, they show radically different performance profiles. To complicate this technology space, product vendors of J2EE products typically provide different infrastructure options and tuning techniques to address the requirements of performance and scalability. Therefore it is essential for developers to understand the performance and scalability issues of COTS EJB technologies so that the system can meet the performance requirements. In this paper, we investigate an approach to measure the performance and scalability of COTS EJB technology based on its architecture and technology analysis. A benchmark application is developed and tested to measure the system's performance as both the client load and component infrastructure are scaled up. The empirical results are presented and analyzed to evaluate the performance and scalability of the EJB technology under study.
5940493
Efficient schema design for a pharmaceutical data repository
Large scientific databases often consist of heterogeneous components that differ in the number of attributes and the number of tuples. In this paper, we show that increased performance is achieved when a complex schema is used to represent different components of a data repository. The driving application used in this study is a pharmaceutical drug repository. The types of access patterns associated with this repository consist of the retrieval of a selected set of attribute values for a consecutive or a random set of tuples. These consecutive and random access patterns, which are typical of a drug discovery experiment, are used to measure the data retrieval throughput for different schemas.
11623191
Mapping component specifications to Enterprise JavaBeans implementations
Component-based software development has become an important approach to building complex software systems. Much research focuses on component specification to achieve the advantages of the component-based approach in theory. Most of this research pays little attention to the mappings from component specifications to component implementations. However, the mappings are important because they determine whether the implementations perform satisfactorily to meet the specifications. After presenting a general approach to component specification and the technology of Enterprise JavaBeans (EJB) component model, this paper presents three approaches to mapping from component specification to EJB implementation. This paper uses a course registration system as an example to demonstrate the ideas. The approaches presented will be helpful to those who are working on the realizations of component systems.
29049246
Iterative detection for BLAST systems with an arbitrary number of receive antennas
Turbo-coded Vertical Bell Labs Layered Space-Time Architecture (V-BLAST) is a multiple-antenna system employing turbo codes and bit-interleaving to offer flexible rates and high-speed wireless data communications. The conventional detection techniques based on one-shot demodulation and decoding algorithms may suffer poor performance or simply fail when there are fewer receive antennas than transmit antennas or when the multiple-input-multiple-output (MIMO) channel exhibits strong spatial correlations. We propose employing an iterative demodulation and decoding algorithm that solves these problems and greatly extends the applicability of V-BLAST. Simulations demonstrate that iterative V-BLAST offers the best-known performance in a wide range of settings. Through complexity analysis, we show that (a) the incremental computing complexity is small, although additional memory is required, compared with the conventional one-shot maximum likelihood (ML) decoding method, and (b) an iterative algorithm employing generalized sphere decoding will be a low-complexity, memory-reduced, and high-performance solution. We also give extensions to the technique beyond simple V-BLAST. In addition, when feedback from the receiver to the transmitter is available, we illustrate how to adapt code rate, modulation, and the power distribution to take advantage of the channel knowledge. With a combination of the “best in class” receiver performance and the ability to decode V-BLAST transmissions with fewer receive antennas than transmit antennas, the techniques described here can be viewed as key “technology enablers” for BLAST/MIMO in next-generation systems.