Robert van Engelen

Supporting Timing Analysis by Automatic Bounding of LoopIterations

Static timing analyzers, which are used to analyze real-time systems, need to know the minimum and maximum number of iterations associated with each loop in a real-time program so accurate timing predictions can be obtained. This paper describes three complementary methods to support timing analysis by bounding the number of loop iterations. First, an algorithm is presented that determines the minimum and maximum number of iterations of loops with multiple exits. Even when the number of iterations cannot be exactly determined, it is desirable to know the lower and upper iteration bounds. Second, when the number of iterations is dependent on unknown values of variables, the user is asked to provide bounds for these variables. These bounds are used to determine the minimum and maximum number of iterations. Specifying the values of variables is less error prone than specifying the number of loop iterations directly. Finally, a method is given to tightly predict the execution time of inner loops whose number of iterations is dependent on counter variables of outer level loops. This is accomplished by formulating the total number of iterations of a loop in terms of summations and solving the resulting equation. These three methods have been successfully integrated in an existing timing analyzer that predicts the performance for optimized code on a machine that exploits caching and pipelining. The result is tighter timing analysis predictions and less work for the user.

A Benchmark Suite for SOAP-based Communication in Grid Web Services

The convergence of Web services and grid computing has promoted SOAP, a widely used Web services protocol, into a prominent protocol for a wide variety of grid applications. These applications differ widely in the characteristics of their respective SOAP messages, and also in their performance requirements. To make the right decisions, an application developer must thus understand the complex dependencies between the SOAP implementation and the application. We propose a standard benchmark suite for quantifying, comparing, and contrasting the performance of SOAP implementations under a wide range of representative use cases. The benchmarks are defined by a set of WSDL documents. To demonstrate the utility of the benchmarks and to provide a snapshot of the current SOAP implementation landscape, we report the performance of many different SOAP implementations (gSOAP, AxisJava, XSUL and bSOAP) on the benchmarks, and draw conclusions about their current performance characteristics.

Code generation techniques for developing light-weight XML Web services for embedded devices

This paper presents specialized code generation techniques and runtime optimizations for developing light-weight XML Web services for embedded devices. The optimizations are implemented in the gSOAP Web services development environment for C and C++. The system supports the industry-standard XML-based Web services protocols that are intended to deliver universal access to any networked application that supports XML. With the standardization of the Web services protocols and the availability of toolkits such as gSOAP for developing embedded Web services, new opportunities emerge to integrate embedded systems into larger frameworks of interconnected applications and systems accessing dynamic resources on the Web ranging from hand-held and embedded devices to databases, clusters, and Grids.

A unified framework for nonlinear dependence testing and symbolic analysis

This paper presents a unified approach for generalized induction variable recognition and substitution, pointer analysis, analysis of conditionally updated variables, value range analysis, array region analysis, and nonlinear dependence testing. The analysis techniques share a well-defined uniform approach based on the chains of recurrences algebra. The uniform algebraic approach provides a powerful unified framework for developing analysis algorithms for restructuring compilers. The paper introduces a new set of analysis algorithms that accurately handle conditional control flow, pointer arithmetic, and nonlinear symbolic expressions in loops, which are known to be problematic for conventional restructuring compilers.

VISTA: a system for interactive code improvement

Software designers face many challenges when developing appli¿cations for embedded systems. A major challenge is meeting the conflicting constraints of speed, code density, and power consump¿tion. Traditional optimizing compiler technology is usually of little help in addressing this challenge. To meet speed, power, and size constraints, application developers typically resort to hand-coded assembly language. The results are software systems that are not portable, less robust, and more costly to develop and maintain. This paper describes a new code improvement paradigm imple¿mented in a system called vista that can help achieve the cost/performance trade-offs that embedded applications demand. Unlike traditional compilation systems where the smallest unit of compilation is typically a function and the programmer has no con¿trol over the code improvement process other than what types of code improvements to perform, the vista system opens the code improvement process and gives the application programmer, when necessary, the ability to finely control it. In particular, vista allows the application developer to (1) direct the order and scope in which the code improvement phases are applied, (2) manually specify code transformations, (3) undo previously applied transformations, and (4) view the low-level program representation graphically. vista can be used by embedded systems developers to produce applications, by compiler writers to prototype and debug new low-level code transformations, and by instructors to illustrate code transformations (e.g., in a compilers course).

Efficient Symbolic Analysis for Optimizing Compilers

Because most of the execution time of a program is typically spend in loops, loop optimization is the main target of optimizing and restructuring compilers. An accurate determination of induction variables and dependencies in loops is of paramount importance to many loop optimization and parallelization techniques, such as generalized loop strength reduction, loop parallelization by induction variable substitution, and loop-invariant expression elimination. In this paper we present a new method for induction variable recognition. Existing methods are either ad-hoc and not powerful enough to recognize some types of induction variables, or existing methods are powerful but not safe. The most powerful method known is the symbolic differencing method as demonstrated by the Parafrase-2 compiler on parallelizing the Perfect Benchmarks(R). However, symbolic differencing is inherently unsafe and a compiler that uses this method may produce incorrectly transformed programs without issuing a warning. In contrast, our method is safe, simpler to implement in a compiler, better adaptable for controlling loop transformations, and recognizes a larger class of induction variables.

Benchmarking XML processors for applications in grid web services

Web services based specifications have emerged as the underlying architecture for core grid services and standards, such as WSRF. XML is inextricably inter-twined with Web services based specifications, and as a result the design and implementation of XML processing tools plays a significant role in grid applications. These applications use XML in a wide variety of ways, including workflow specifications, WS-Security based documents, service descriptions in WSDL, and on-the-wire format in SOAP-based communication. The application characteristics also vary widely in the use of XML messages in their performance, memory, size, and processing requirements. Numerous XML processing tools exist today, each of which is optimized for specific features. To make the right decisions, grid application and middleware developers must thus understand the complex dependencies between XML features and the application. We propose a standard benchmark suite for quantifying, comparing, and contrasting the performance of XML processors under a wide range of representative use cases. The benchmarks are defined by a set of XML schemas and conforming documents. To demonstrate the utility of the benchmarks and to provide a snapshot of the current XML implementation landscape, we report the performance of many different XML implementations, on the benchmarks, and draw conclusions about their current performance characteristics. We also present a brief analysis on the current shortcomings and required critical design changes for multi-threaded XML processing tools to run efficiently on emerging multi-core architectures

Secure Web Services with Globus GSI and gSOAP

In this paper we describe a plug-in for the gSOAP Toolkit that allows development of Web Services exploiting the Globus Security Infrastructure (GSI). Our plug-in allows the development of GSI enabled Web Services and clients, with full support for mutual authentication/authorization, delegation of credentials and connection caching. The software provides automatic, transparent transport-level security for Web Services and is freely available.

CTADEL: a generator of multi-platform high performance codes for PDE-based scientific applications

The CTADEL system provides an automated means of generating specific high performance scientific codes optimized for serial, vector, or shared virtual memory and distributed memory parallel computer architectures. One of the key elements of this system is the employment of algebraic simplification techniques and powerful methods for global common subexpression elimination to guarantee the generation of efficient high performance codes for various target architectures. In this paper we present the CTADEL Code-generation Tool for Applications based on Differential Equations using high-level Language specifications. A prototype implementation has been developed which is limited to explicit finite difference methods as numerical solution method. Performance results of the codes generated with this prototype implementation will be presented for a limited area numerical weather forecast routine on various hardware platforms. These results show that generation of efficient code is well feasible within the presented approach.

A framework for service-oriented computing with C and C++ Web service components

Service-oriented architectures use loosely coupled softwareservices to support the requirements of business processes andsoftware users. Several software engineering challenges have to beovercome to expose legacy C and C++ applications and specializedsystem resources as XML-based software services. It is critical todevise effective bindings between XML and C/C++ data to efficientlyinteroperate with other XML-based services. Binding applicationdata to XML has many software solutions, ranging from genericdocument object models to idiosyncratic type mappings. A safebinding must conform to XML validation constraints, guarantee typesafety, and should preserve the structural integrity ofcommunicated application data. However, tight XML bindings imposemapping constraints that can hamper interoperability betweenservices. This paper presents a framework for constructing looselycoupled C/C++ services based on a programming model that integratesXML bindings into the C and C++ syntax. The concepts behind thebindings are generic, which makes the approach applicable to otherprogramming languages.