No abstract

1Many software libraries (e.g., the Booch C++ Components, libg++, NIHCL, COOL) provide components (classes) that implement data structures. Each component is written by hand and represents a unique combination of features (e.g. concurrency, data structure, memory allocation algorithms) that distinguishes it from other components.We argue that this way of building data structure component libraries is inherently unscalable. Libraries should not enumerate complex components with numerous features; rather, libraries should take a minimalist approach: they should provide only primitive building blocks and be accompanied by generators that can combine these blocks to yield complex custom data structures.In this paper, we describe a prototype data structure generator and the building blocks that populate its library. We also present preliminary experimental results which suggest that this approach does not compromise programmer productivity nor the run-time performance of generated data structures. IntroductionSoftware libraries are a popular means of boosting programmer productivity and reducing software development time and cost. We claim that today's method of constructing libraries is inherently unscalable. Every time a new feature is added -such as choosing between persistent data structures and nonpersistent data structures -the number of components in the library doubles. The number of features that are represented in contemporary libraries is just a small fraction of those that are actually needed. In fact, most data structures in database systems, operating systems, and compilers are far more complicated than those offered in today's libraries. No library constructed by the current means could ever possibly hope to encompass the enormous spectrum of data structures that arise in practice. Clearly, a new strategy for building data structure libraries is needed.To be scalable, libraries must offer much more primitive building blocks and be accompanied by generators that compose blocks to yield the data structures needed by application programmers. In this paper, we propose a generative means for realizing scalable data structure libraries. The composition techniques that we propose are based on the GenVoca model [Bat92b], a model for constructing hierarchical software systems from reusable components. The techniques that we use do not rely on inheritance as offered by contemporary object-oriented languages. Instead, GenVoca models system implementations as combinations of layered software components.We begin by examining the designs of two component libraries and identifying their limitations and weaknesses. We then explain our generative approach that relies on a layered composition of

PREDATOR is a data structure precompiler that generates emient code for maintaining and querying complex data structures. It embodies a novel component reuse technology that transcends traditional generic data types. In this papec we explain the concepts of our work and our prototype system. We show how complex data structures can be specijied as compositions of software building blocks, and present performance results that compare PREDATOR output to hand-optimized programs. 1: IntroductionDesigning, writing, and debugging programs is a timeintensive task. Of the different aspects of writing programs of moderate to large complexity, implementing data structures often consumes a disproportionally large fraction of a programmer's time. A data structure compiler is a suite of tools that reduces the burden of programming data structures. There have been several attempts to produce such compilers. Three examples are [lo, 19, 251. In general, however, data structure compilers have not achieved a broad level of acceptance. The reasons include inadequate performance, unnecessary complexity, host language restrictions, and limited scope.Eliminating the drudgery of programming data structures is clearly an important problem. We believe the solution rests on a software component technology that is defined by a combination of concepts from databases, compilers, transformation systems, and domain modelling.While none of these concepts are new, we are presenting a unique combination that yields a technology for assembling complex data structures from plug-compatible components.1. This research supported in part by grants from Texas Instruments, IBM, and Digital Equipment Corporation.Two goals of a data structure compiler should be: 1. To generate efficient code, i.e. within 10% of highly tuned and hand optimized code. 2. To allow programs to be easily written in a data structure independent manner. This would allow data structures to be changed without modifying the application program. When programs employ component technologies, there are two distinct phases of software development: component creation and application writing. Component creation involves the definition of the interface and the implementation of software components. In the application writing phase, components are combined with customized (application-specific) code to form the completed program. Occasionally, a programmer is forced to implement new components, thus mixing the two phases. Our research aims to simplify component creation and reduce the necessity of implementing new components. This division of specification and tools from application programming is not unique [26, 233. Our research concentrates more on programmer productivity and code efficiency than on program evolution and maintenance.Our project is called PREDATOR, which is a (misspelled) acronym for PREcompiler for DAta sTRuctures. In this paper, we motivate the need for PREDATOR by exposing important limitations of traditional parameterized types, the central concept upon which all existin...

P2 is a scalable compiler for collection data structures. High-1evel abstractions insulate P2 users from data structure implementation details. By specifying a target data structure as a composition of components from a reuse library, the P2 compiler replaces abstract operations with their concrete implementations.LEAPS is a production system compiler that produces the fastest sequential executable of 0PS5 rule sets. LEAPS is a hand-written, highly-tuned, performance-driven application that relies on complex data structures. Reengineering LEAPS using P2 was an acid test to evaluate P2's scalability, productivity benefits, and generated code performance.In this paper, we present some of our experimental results and experiences in this reengineering exercise. We show that P2 scaled to this complex application, substantially increased productivity, and provided unexpected performance gains.

We present a model of the data structure domain that is expressed in terms of the GenVoca domain modeling concepts [Bat91]. We show how familiar data structures can be encapsulated as realms of plug-compatible, symmetric, and reusable components, and we show how complex data structures can be formed from their composition. The target application of our research is a precompiler for specifying and generating customized data structures.Keywords: software building-blocks, domain modeling, software reuse, data structures. IntroductionA fundamental goal of software engineering is to understand how software components fit together to form complex systems. Domain modeling is a means to achieve this goal; it is the study of a domain of similar software systems to identify the primitive and reusable components of that domain and to show how compositions of components not only explain existing systems but also predict families of yet unbuilt systems that have interesting and novel properties. In essence, domain models can be blue-prints for the as-yet-to-be-achieved software building-block technologies.Domain modeling is presently an immature discipline [Pri91]. Besides the general skepticism that characteristically accompanies new areas of research, domain modelers face three difficult barriers to the development and popularization of their ideas:• Domain models must be expressed in terms of constructs and software organization principles that are domain-independent. Domain-specific constructs are, by definition, not applicable to other domains. Models based exclusively on domain-specific ideas are both difficult to understand and contribute little to helping other researchers understand how other domains can be modeled.• In order to understand a domain model, one must be intimately familiar with the domain itself. It is often hard for non-experts (and even experts) to appreciate the difficulty of a domain modeling effort and its contributions.• Domain models are nontrivial. One cannot accept a domain model on face value; it is essential that there be an accompanying implementation for model validation. Unfortunately, because of the time and expense involved, few models are validated. Without validation, however, the significance of a model is questionable.In this paper, we attempt to cross all three barriers (or alternatively, we show why each is hard to cross!). First, we review the GenVoca domain modeling concepts, which have been validated on the com- We believe our research makes two contributions. First, our domain model outlines the beginnings of a technology for synthesizing customized object base software from prewritten building-blocks. Persistency is but one of many options (i.e., building-blocks) that can be selected. Our paper will stress the nonpersistent (i.e., data structure) aspects of this technology. Second, we see our work as an example of the types of activities and problems that are commonly encountered in a domain modeling effort. Other researchers may benefit in their domain modeling eff...