Mechanisms and methods for performance tuning of reusable software components

Software reuse has the potential for attacking software productivity and quality problems. When reuse becomes technically feasible, a software components industry similar in nature to those of mature engineering disciplines will emerge. Every component will have an implementation-independent, abstract specification of its functionality. Multiple components will be available from different manufacturers to provide the same functionality with different performance characteristics. In this industry, a new software component will be constructed largely from available reusable components. Some of the marketed components will have a specific performance and will be tailored to execute on a particular hardware architecture. Some others will be more general and their performance will be tunable by clients to suit their performance requirements. There are three major factors that affect the performance of a client of an abstract functionality--the specific concrete component chosen for realizing the abstraction, components used for the constituent abstractions of this component, and the manner in which a hardware architecture is utilized in executing the component. It is possible to design programming language mechanisms and other methods to facilitate construction of performance-tunable components, whereby clients can be allowed effective control over each significant aspect of performance. The mechanisms and methods are demonstrated to be possible in a most likely, but apparently restrictive, view of the components industry where a component is expected to be marketed only in a sealed form, along with a specification of its functionality and performance information. Among the contributions of the dissertation are a layered model for software construction and a characterization of a reusable software components industry. The dissertation, for the first time, demonstrates the need for programming language mechanisms for allowing multiple implementations (with different performance behavior) of an abstraction, and proposes mechanisms for constructing and using highly performance-tunable reusable components. It also discusses a hardware architecture-independent method for distribution of programs built from reusable software components. The method permits extraction of parallelism at any granularity and it does not depend on the availability of source code of components to achieve these objectives.