No full-text available
To read the full-text of this research,
you can request a copy directly from the author.
Theory and Practice of Incremental Subtyping Tests and Message Dispatching
Abstract
The incremental version of the subtyping and dispatching problems is to maintain a data struc- ture supporting these queries in presence of additions of ty pes (along with their accompanying meth- ods) to the inheritance hierarchy. We give theoretical algo rithms for these problems, and analyze their asymptotic behavior. The algorithms in the single inherita nce setting use linear space, and give constant time for subtyping tests and updates, and logarithmic time for dispatching queries and updates. In the multiple-inheritance setting, these bounds depend on an integer , which can be thought of as a metric of the complexity of the topology of the inheritance hierarc hy. Our algorithms compare favorably (on a data set of hierarchi es totaling some 76 thousand types) with previously published algorithms for the static varian t of these problems. In fact, our new dis- patching data structure based on a type slicing technique, exhibits very significant improvements over row-displacement, not only in terms of the time for creating the underlying dat a structure, but also in terms of total space used. (Row displacement due to Driesen and H ¨ olzle is considered one of the the best technique for compressing dispatching tables.) This data structure also improves the space of the compact dispatch tablesalgorithm, which is considered even better than row displacement in some hi- erarchies.1 The results have theoretical and practical applications to the more general problem of dispatching multi-methods.
ResearchGate has not been able to resolve any citations for this publication.
CommonLoops blends object-oriented programming smoothly and tightly with the procedure-oriented design of Lisp. Functions and methods are combined in a more general abstraction. Message passing is invoked via normal Lisp function call. Methods are viewed as partial descriptions of procedures. Lisp data types are integrated with object classes. With these integrations, it is easy to incrementally move a program between the procedure and object-oriented styles.
One of the most important properties of CommonLoops is its extensive use of meta-objects. We discuss three kinds of meta-objects: objects for classes, objects for methods, and objects for discriminators. We argue that these meta-objects make practical both efficient implementation and experimentation with new ideas for object-oriented programming.
CommonLoops' small kernel is powerful enough to implement the major object-oriented systems in use today.
Message passing is a crucial feature of any object-oriented language implemen-tation. Even more so in dynamically typed languages, where the absence of com-pile-time type information forces the implementation to perform run-time type checking at each message send. Traditional techniques for the implementation of message passing in those languages favor flexibility and space efficiency over speed. This paper explores an alternative called compact dispatch tables suited to environments with high requirements in time and space efficiency. Compact dis-patch tables are one solution to achieve fast, and constant-time, message passing in dynamically typed languages and to bring them one step closer to the efficien-cy of statically typed languages. Abstract Message passing is a crucial feature of any object-oriented language implementation. Even more so in dynamically typed languages, where the absence of compile-time type information forces the implementation to perform run-time type checking at each message send. Traditional tech-niques for the implementation of message passing in those languages favor flexibility and space efficiency over speed. This paper explores an alternative called compact dispatch tables suited to environments with high requirements in time and space efficiency. Compact dispatch tables are one solution to achieve fast, and constant-time, message passing in dynamically typed languages and to bring them one step closer to the efficiency of statically typed languages.
Incremental updates to multiple inheritance hierarchies are becoming more prevalent with the increasing number of persistent applications supporting complex objects, making the efficient computation of lattice operations such as greatest lower bound (GLB), least upper bound (LUB), and subsumption more and more important. General techniques for the compact encoding of a hierarchy are presented. One such method is to plunge the given ordering into a boolean lattice of binary words, leading to an almost constant-time complexity of the lattice operations. The method is based on an inverted version of the encoding of Ait-Kaci et al. to allow incremental update. Simple grouping is used to reduce the code space while keeping the lattice operations efficient. Comparisons are made to an incremental version of the range compression scheme of Agrawal et al., where each class is assigned an interval, and relationships are based on containment in the interval. The result is two encoding methods which have their relative merits. The former being better for smaller, more structured hierarchies, and the latter for larger, less organized hierarchies.
A type inclusion test is a procedure to decide whether two types are related by a given subtyping relationship. An efficient implementation of the type inclusion test plays an important role in the performance of object oriented programming languages with multiple subtyping like C++, Eiffel or Java. There are well-known methods for performing fast constant time type inclusion tests that use a hierarchical bit vector encoding of the partial ordered set representing the type hierarchy. The number of instructions required by the type inclusion test is proportional to the length of those bit vectors. We present a new algorithm based on graph coloring which computes a near optimal hierarchical encoding of type hierarchies. The new algorithm improves significantly on previous results - it is faster, simpler and generates smaller bit vectors.
Although there is a large body of research on the time overhead of object oriented programs, there is little work on memory
overhead. This paper takes an empirical approach to the study of this overhead, which turns out to be significant in the presence
of multiple inheritance. We study the performance, in terms of overhead to object size of three compilation strategies: separate
compilation, whole program analysis, and user annotations as done in C++. A variant to each such strategy is the inclusion
of pointers to indirect virtual bases in objects. Using a database of several large multiple inheritance hierarchies, spanning
7000 classes, several application domains and different programming languages we find that in all strategies there are certain
classes which give rise a large number of compiler generated fields in their object layout. We then study the efficacy of
the recently introduced inlining and bidirectional object layout optimization techniques, and show that an average saving
of close to 50% in this overhead can be achieved.
Multivariant functions in Kea are a statically-typed form of the multi-methods of CLOS (Keene, 1989) but encapsulation is retained. Multivariants permit fine typing distinctions to be made, allow despatching to be avoided in some cases, and may be used to avoid some restrictions of the contravariance rule.
Once multivariant functions are introduced by example, the semantics of the despatch of multivariants are provided, based on the generation of despatching variants. Three issues arise with despatching: redundancy, ambiguity, and exhaustiveness of a (partially-ordered) set of variants with respect to a function call. It is shown that the approach taken here is consistent with separate compilation.
Object-oriented systems must implement message dispatch efficiently in order not to penalize the object-oriented programming style. We characterize the performance of most previously published dispatch techniques for both statically- and dynamically-typed languages with both single and multiple inheritance. Hardware organization (in particular, branch latency and superscalar instruction issue) significantly impacts dispatch performance. For example, inline caching may outperform C++-style “vtables” on deeply pipelined processors even though it executes more instructions per dispatch.
We also show that adding support for dynamic typing or multiple inheritance does not significantly impact dispatch speed for most techniques, especially on superscalar machines. Instruction space overhead (calling sequences) can exceed the space cost of data structures (dispatch tables), so that minimal table size may not imply minimal run-time space usage.
Traditional implementations of multiple inheritance bring about not only an overhead in terms of run-time but also a significant increase in object space. For example, the number of compiler-generated fields in a certain object can be as large as quadratic in the number of its subobjects. The problem of efficient object layout is compounded by the need to support two different semantics of multiple inheritance: shared, in which a base class inherited along distinct paths occurs only once in the derived class, and repeated, in which this base has multiple distinct occurrences in the derived. In this theoretical and foundational paper, we introduce two new techniques to optimize memory layout for multiple inheritance. The main ideas behind these techniques are the inlining of virtual bases and bidirectional memory layout. Our techniques never increase time overhead, and usually even decrease it. We show that in some example hierarchies, more than ten-fold reduction in the space overhead can be achieved. We analyze the complexity of the algorithms to apply these techniques, and give theorems to estimate the efficacy of this application. For concreteness, techniques and examples are discussed in the context of C++.
We have built a novel and efficient replay debugger for our Standard ML compiler. Debugging facilities are provided by instrumenting the user's source code; this approach, made feasible by ML's safety property, is machine-independent and back-end independent. ...
The efficiency of dynamic dispatch is a major impediment to theadoption of multimethods in object-oriented languages. In thisarticle, we propose a simple multimethod dispatch scheme based oncompressed dispatch tables. This scheme is applicable to anyobject-oriented language using a method precedence order thatsatisfies a specific monotonous property (e.g., as Cecil and Dylan)and guarantees that dynamic dispatch is performed in constant time,the latter being a major requirement for some languages andapplications. We provide efficient algorithms to build the dispatchtables, provide their worst-case complexity, and demonstrate theeffectiveness of our scheme by real measurements performed on twolarge object-oriented applications. Finally, we provide a detailedcomparison of our technique with other existing techniques.
Lattice operations such as greatest lower bound (GLB), least upper bound (LUB), and relative complementation (BUTNOT) are becoming more and more important in programming languages supporting object inheritance. We present a general technique for the efficient implementation of such operations based on an encoding method. The effect of the encoding is to plunge the given ordering into a boolean lattice of binary words, leading to an almost constant time complexity of the lattice operations. A first method is described based on a transitive closure approach. Then, a more space-efficient method minimizing code-word length is described. Finally, a powerful grouping technique called modulation is presented which drastically reduces code space while keeping all three lattice operations highly efficient. This technique takes into account idiosyncrasies of the topology of the poset being encoded which are quite likely to occur in practice. All methods are formally justified. We see this work a...
Single dispatch involves performing at run-time a multi-way switch over the possible classes of the receiver. Most object-oriented systems implement this switch as an array lookup using a table-based technique or as a binary search using a tree-based technique. However, each of these is the best choice only under a particular circumstance; neither outperforms the other under all circumstances. In this paper, we present a time and space efficient implementation of the switch that employs the table-based technique when an array lookup outperforms a binary search and the tree-based technique when a binary search outperforms an array lookup. Further, when neither an array lookup nor a binary search is superior, our scheme blends the two techniques in a manner that gains the benefits of both without suffering the disadvantages of either. We relate our scheme to recent work and discuss extending it to implement multiple dispatch.
Introduction
The Common Lisp Object System is an object-oriented extension to Common Lisp as defined in Common Lisp: The Language, by Guy L. Steele Jr. It is based on generic functions, multiple inheritance, declarative method combination, and a meta-object protocol.
The first two chapters of this specification present a description of the standard Programmer Interface for the Common Lisp Object System. The first chapter contains a description of the concepts of the Common Lisp Object System, and the second contains a description of the functions and macros in the Common Lisp Object System Programmer Interface. The chapter "The Common Lisp Object System Meta-Object Protocol" describes how the Common Lisp Object System can be customized.
The fundamental objects of the Common Lisp Object System are classes, instances, generic functions, and methods.
A class object determines the structure and behavior of a set of other objects, which are called its instances. Every Common Lisp object is an instance of a class. The class of an object determines the set of operations that can be performed on the object.
A generic function is a function whose behavior depends on the classes or identities of the arguments supplied to it. A generic function object contains a set of methods, a lambda-list, a method combination type, and other information. The methods define the class-specific behavior and operations of the generic function; a method is said to specialize a generic function. When invoked, a generic function executes a subset of its methods based on the classes of its arguments.
A generic function can be used in the same ways that an ordinary function can be used in Common Lisp; in particular, a generic function can be used as an argument to funcall and apply and can be given a global or a local name.
A method is an object that contains a method function, a sequence of parameter speclalizers that specify when the given method is applicable, and a sequence of qualifiers that is used by the method combination facility to distinguish among methods. Each required formal parameter of each method has an associated parameter specializer, and the method will be invoked only on arguments that satisfy its parameter specializers.
The method combination facility controls the selection of methods, the order in which they are run, and the values that are returned by the generic function. The Common Lisp Object System offers a default method combination type and provides a facility for declaring new types of method combination.
The order maintenance problem is that of maintaining a list under a sequence of Insert and Delete operations, while answering Order queries (determine which of two elements comes first in the list). We give two new algorithms for this problem. The first algorithm matches the O(1) amortized time per operation of the best previously known algorithm, and is much simpler. The second algorithm permits all operations to be performed in O(1) worst-case time.
SmallEiffel is an Eiffel compiler which uses a fast simple type inference mechanism to remove most late binding calls, replacing them by static bindings. Starting from the system's entry point, it compiles only statically living code, which saves compiling and then removing dead code. As the whole system is analyzed at compile time, multiple inheritance and genericity do not cause any overhead. SmallEiffel features a coding scheme which eliminates the need for virtual function tables. Dynamic dispatch is implemented without any array access but uses a simple static binary branch code. We show that this implementation makes it possible to use modern hardware very efficiently. It also allows us to inline more calls even when dynamic dispatch is required. Some more dispatch sites are removed after the type inference algorithm has been performed, if the dioeerent branches of a dispatch site lead to the same code. The advantage of this approach is that it greatly speeds up execution time and...
The speed of message dispatching is an important issue in the overall performance of object-oriented programs. We have developed an algorithm for constructing efficient dispatch functions that combines novel algorithms for efficient single dispatching, multiple dispatching, and predicate dispatching. Our algorithm first reduces methods written in the general predicate dispatching model (which generalizes single dispatching, multiple dispatching, predicate classes and classifiers, and pattern-matching) into ones written using a simpler multimethod dispatching model. Our algorithm then computes a strategy for implementing multiple dispatching in terms of sequences of single dispatches, representing the strategy as a lookup DAG. Finally, our algorithm computes an implementation strategy separately for each of the single dispatches, producing for each dispatch a dispatch tree, which is a binary decision tree blending class identity tests, class range tests, and table lookups. Our algorithm exploits any available static information (from type declarations or class analysis) to prune unreachable paths from the lookup DAG, and uses any available dynamic profile information to minimize the expected time to search the dispatch trees. We measure the effectiveness of our dispatching algorithms on a collection of large Cecil programs, compiled by the Vortex optimizing compiler, showing improvements of up to 30% over already heavily optimized baseline versions.
In this section, we describe the major techniques in current use for the optimization of polymorphic calls. We present the
techniques and discuss runtime aspects like estimated memory cost and responsiveness. Detailed estimates of run-time call
cost are delayed until Section 5, where we bring hardware into the picture.
We give a representation for linked lists which allows to efficiently insert and delete objects in the list and to quickly determine the order of two list elements. The basic data structure, called an indexed BB []-tree, allows to do n insertions and deletions in O(n log n) steps and determine the order in constant time, assuming that the locations of the elements worked at are given. The improved algorithm does n insertions and deletions in O(n) steps and determines the order in constant time. An application of this provides an algorithm which determines the ancestor relationship of two given nodes in a dynamic tree structure of bounded degree in time O(1) and performs n arbitrary insertions and deletions at given positions in time O(n) using linear space.
A new data structure called the q-fast trie is introduced. Given a set of N records whose keys are distinct nonnegative integers less than some initially specified bound M, a q-fast trie uses space O(N) and time O(√log M) for insertions, deletions, and all the retrieval operations commonly associated with binary trees. A simpler but less space efficient data structure called the p-fast trie is defined.
A data structure called a PQ-tree is introduced. PQ-trees can be used to represent the permutations of a set U in which various subsets of U occur consecutively. Efficient algorithms are presented for manipulating PQ-trees. Algorithms using PQ-trees are then given which test for the consecutive ones property in matrices and for graph planarity. The consecutive ones test is extended to a test for interval graphs using a recently discovered fast recognition algorithm for chordal graphs. All of these algorithms require a number of steps linear in the size of their input.
Three techniques in computational geometry are explored: Scaling solves a problem by viewing it at increasing levels of numerical precision; activation is a restricted type of update operation, useful in sweep algorithms; the Cartesian tree is a data structure for problems involving maximums and minimums. These techniques solve the minimum spanning tree problem in Rk1 and Rk@@@@ in O(n(lg n)rlg lg n) time and O(n) space, where for Rk@@@@ and k ≥ 3, r &equil; k−2; for Rk1, r &equil; 1, 2, 4 for k &equil; 3, 4, 5 and r &equil; k for k > 5. Other problems solved include Rk1and Rk all nearest neighbors, post office and maximum spanning tree; Rk maxima, Rk rectangle searching problems, and Zkp all nearest neighbors (1 ≤ p ≤ @@@@).
Polymorphic inline caches (PICs) provide a new way to reduce the overhead of polymorphic message sends by extending inline caches to include more than one cached lookup result per call site. For a set of typical object-oriented SELF programs, PICs achieve a median speedup of 11%.
As an important side effect, PICs collect type information by recording all of the receiver types actually used at a given call site. The compiler can exploit this type information to generate better code when recompiling a method. An experimental version of such a system achieves a median speedup of 27% for our set of SELF programs, reducing the number of non-inlined message sends by a factor of two.
Implementations of dynamically-typed object-oriented languages have been limited by the paucity of type information available to the compiler. The abundance of the type information provided by PICs suggests a new compilation approach for these languages, adaptive compilation. Such compilers may succeed in generating very efficient code for the time-critical parts of a program without incurring distracting compilation pauses.
Subtyping test, i.e., determining whether one type is a subtype of another, are a frequent operation during the execution of object-oriented programs. The challenge is in encoding the hierarchy in a small space, while simulataneously making sure that subtyping tests have efficient implmentation. We present a new scheme for encoding multiple and single inheritance hierarchies, which, in the standardized hierarchies, reduces the footprint of all previsously published schemes. The scheme is called PQ-encoding after PQ-trees, a data structure previously used in graph theory for finding the orderings that satisfy a collection of constraints. In particular, we show that in the traditional object layout model, the extra memory requirement for single inheritance hierarchies is zero. In the PQ-encoding subtyping tests are constant time, and use only two comparisons. Other than PQ-trees, PQ-encoding uses several novel optimization techniques. These techniques are applicable also in improving the performance of otehr, previously published, encoding schemes.
Dealing with multiple inheritance hierarchies is a problem both for designers of compilers for object-oriented languages supporting multiple inheritance and for users who have to model complex hierarchical data with languages where classes are not first-class objects (such as C++). We propose here two techniques that yield a new way of encoding a multiple inheritance hierarchy. We first give a proven algorithm to incrementally transform any hierarchy into a lattice. We then develop a technique, called compact hierarchical encoding, which provides constant time for subsumption between two nodes of the lattice, using the codes as a representation of the associated order (transitive closure). The encoding builds a lattice mapping to a powerset inclusion lattice and can thus be implemented efficiently using bit-vectors. It offers an interesting alternative to the modulation technique proposed by [ABL89], because it produces more compact encoding on complex hierarchies that are frequent in object-oriented applications.
Object-oriented languages (OOLs) are becoming increasingly popular in software development. The modular units in such languages are abstract data types called classes, comprising data and functions (or selectors in the OOL parlance); each selector has possibly multiple implementations (or methods in OOL parlance) each in a different class. These languages support reusability of code/functions by allowing a class to inherit methods from its superclass in a hierarchical arrangement of the various classes. Therefore, when a selector s is invoked in a class c, the relevant method for s inherited by c has to be determined. That is the fundamental problem of method-lookup in object-oriented programs. Since nearly every statement of such programs calls for a method-lookup, efficient support of OOLs crucially relies on the method-lookup mechanism. The challenge in implementing the method-lookup, as it turns out, is to use only a reasonable amount of table-space while keeping the query time down. Substantial research has gone into achieving improved space vs time trade-off in practice. In this paper, we present new theoretical as well as practical results. Our theoretical result is an algorithm for the method-lookup problem that has improved time/space bounds. This solution as such proves relatively inefficient when implemented. However using our intuition from there, we develop an alternate practical strategy that we call the selective strategy. We apply the selective strategy to two prevalent class hierarchies, namely the NeXTStep 3.2 (for Objective-C) and Objectworks 4.1 (for Smalltalk). As a result we derive solutions that are, in both cases, significantly faster and substantially less space-consuming at the same time compared to the most efficient practical approaches available for these OOLs. We believe that our selective strategy will be a practical approach for other similar OOLs as well.
We present a data structure, based upon a hierarchically decomposed tree, which enables us to manipulate on-line a priority queue whose priorities are selected from the interval 1,?,n with a worst case processing time of
(log logn) per instruction. The structure can be used to obtain a mergeable heap whose time requirements are about as good. Full details are explained based upon an implementation of the structure in a PASCAL program contained in the paper.
Efficient implementation of type inclusion is an important feature of object oriented programming languages with multiple inheritance. The idea is to associate to each type a subset of a set S={1,...,k} such that type inclusion coincides with subset inclusion. Such an embedding of types into 2S (the lattice of all subsets of S) is called a bit-vector encoding of the type hierarchy. In this paper, we show that most known bit-vector encoding methods can be inserted on a general theoretical framework using graph coloration, namely the notion of a simple encoding. We use the word simple because all these methods are heuristics for the general bit-vector encoding problem, known as the 2-dimension problem. First we provide a correct algorithm for partial orders based on simple encoding, improving the algorithm of Krall, Vitek, and Horspool (1997). Second we show that finding an optimal simple encoding is an NP-hard problem. We end with a discussion on some practical issues.
We argue that accessing the transitive closure of relationships is an important component of both databases and knowledge representation systems in Artificial Intelligence. The demands for efficient access and management of large relationships motivate the need for explicitly storing the transitive closure in a compressed and local way, while allowing updates to the base relation to be propagated incrementally. We present a transitive closure compression technique, based on labeling spanning trees with numeric intervals, and provide both analytical and empirical evidence of its efficacy, including a proof of optimality.
We present a new representation for linked lists. This representation allows one to efficiently insert objects into the list and to quickly determine the order of list elements. The basic data structure, called an indexed 2-3 tree, allows one to do n inserts in O(nlogn) steps and to determine order in constant time. We speed up the algorithm by dividing the data structure up into log*n layers. The improved algorithm does n insertions and comparisons in O(nlog*n) steps. The paper concludes with two applications: determining ancestor relationships in a growing tree and maintaining a tree structured environment (context tree).
This book describes the process by which Smalltalk was introduced to people outside Xerox PARC, where it was developed. This book first describes the incredibly exciting history of how Smalltalk was built from scratch. It then goes on to show the way in which Smalltalk was made public. At first, this was an engineering process. Large companies were contacted and offered to participate by porting the Smalltalk VM to their machines, and then running an image provided on tape. Each of these teams then wrote a paper on their experience, and these original papers are included in this book. Xerox PARC also wrote its own paper. These papers are an invaluable source of information for any Smalltalker. They range from overall design issues down to statistics on the work of the VM and image contents.
Self-calibration is a new technique for the study of internal
product metrics, sometimes called “observations” and
calibrating these against their frequency, or probability of occurring
in common programming practice (CPP). Data gathering and analysis of the
distribution of observations is an important prerequisite for predicting
external qualities, and in particular software complexity. The main
virtue of our technique is that it eliminates the use of absolute values
in decision-making, and allows gauging local values in comparison with a
scale computed from a standard and global database. Method profiles are
introduced as a visual means to compare individual projects or
categories of methods against the CPP. Although the techniques are
general and could in principle be applied to traditional programming
languages, the focus of the paper is on object oriented languages using
Java. The techniques are employed in a suite of 17 metrics in a body of
circa thirty thousand Java methods
Selector table indexing is a simple technique for method lookup in object-oriented languages, which yields good performance, is well suited to multiple inheritance and dynamic typing, but is generally disregarded for its prohibitive memory consumption. The large memory footprint is caused by keeping a table of methods, indexed by a selectorcode, for each class in the system. These tables are sparsely filled. A sparse array implementation is presented, which reduces the memory consumption by an order of magnitude, while performing retrieval in constant time. This implementation is discussed in the context of a real programming environment, and compared to selector coloring, a different memory-optimizing technique. The method is shown to be complementary to dynamic caching techniques such as inline caching. 1.
A new technique for multi-method dispatch, called Single-Receiver Projections and abbreviated SRP, is presented. It operates by performing projections onto single-receiver dispatch tables, and thus benefits from existing research into single-receiver dispatch techniques. It provides method dispatch in O(k), where k is the arity of the method. Unlike existing multi-method dispatch techniques, it also maintains the set of all applicable methods. This extra information allows SRP to support languages like CLOS that use next-method. SRP is also highly incremental in nature, so it is well-suited for languages that require separate compilation and languages that allow methods and classes to be added at run-time. SRP uses less data-structure memory than all existing multi-method techniques and has the second fastest dispatch time. Furthermore, if the other techniques are extended to support all applicable methods, SRP becomes the fastest dispatch techniques. RESEARCH PAPER Subject...
We present an practical method to obtain a compact computer memory representation of orders and to compute pairwise comparisons efficiently. The principle of this method is to represent an order P as a union of interval orders P
i
for which an optimal representation is already known (i.e. a union representation of P [Wes85]). For a directed acyclic graph G = (X, U) representing an order P = (X, <p), the preprocessing time complexity is not better than the transitive closure computation cost. In the worst case, the size of the representation is the same that the size of the transitive closure. However, experimental tests give better results, and comparison with the compression technique of Agrawal & al. [ABJ89] is at the advantage of our method for dense orders.
Cecil is a new purely object-oriented language intended to support rapid construction of highquality, extensible software. Cecil combines multi-methods with a classless object model, object-based encapsulation, and optional static type checking. Cecil's static type system distinguishes between subtyping and code inheritance, but Cecil enables these two graphs to be described with a single set of declarations, optimizing the common case where the two graphs are parallel. Cecil includes a fairly flexible form of parameterization, including both explicitly parameterized objects, types, and methods and implicitly parameterized methods related to the polymorphic functions commonly found in functional languages. By making type declarations optional, Cecil aims to support mixed exploratory and production programming styles. This document describes the design of the Cecil language as of March, 1993. It mixes the specification of the language with discussions of design issues and explanations of...
: Optimizing method dispatch is a central issue in object-oriented language implementation. Besides overall efficiency, a major requirement for some languages and applications is constant-time performance. In systems with multi-methods, these requirements are still harder to meet. The compressed dispatch table scheme, presented in [AGS94], was the first to meet them. Its compression algorithm is based on the definition of pole types. In this report, we investigate another structure, namely the dispatch tree, showing that it can also meet those requirements. We show that pole types can be used to compress dispatch trees, and we describe some optimizations of compressed dispatch trees. The resulting run-time structures are yet smaller than compressed dispatch tables. Key-words: multi-methods, run-time dispatch, pole types. (R'esum'e : tsvp) Unite de recherche INRIA Rocquencourt Domaine de Voluceau, Rocquencourt, BP 105, 78153 LE CHESNAY Cedex (France) Telephone : (33 1) 39 63 55 11 -...