New trie data structures which support very fast search operations
Journal of Computer and System Sciences
SMALLTALK-80: the interactive programming environment
SMALLTALK-80: the interactive programming environment
Self-adjusting binary search trees
Journal of the ACM (JACM)
Object oriented programming: an evolutionary approach
Object oriented programming: an evolutionary approach
Two algorithms for maintaining order in a list
STOC '87 Proceedings of the nineteenth annual ACM symposium on Theory of computing
CommonLoops: merging Lisp and object-oriented programming
OOPLSA '86 Conference proceedings on Object-oriented programming systems, languages and applications
A fast method dispatcher for compiled languages with multiple inheritance
OOPSLA '89 Conference proceedings on Object-oriented programming systems, languages and applications
The annotated C++ reference manual
The annotated C++ reference manual
Efficient method dispatch in PCL
LFP '90 Proceedings of the 1990 ACM conference on LISP and functional programming
Optimizing method search with lookup caches and incremental coloring
OOPSLA '92 conference proceedings on Object-oriented programming systems, languages, and applications
Selector table indexing & sparse arrays
OOPSLA '93 Proceedings of the eighth annual conference on Object-oriented programming systems, languages, and applications
Dynamic Perfect Hashing: Upper and Lower Bounds
SIAM Journal on Computing
The design and evolution of C++
The design and evolution of C++
Minimizing row displacement dispatch tables
Proceedings of the tenth annual conference on Object-oriented programming systems, languages, and applications
The direct cost of virtual function calls in C++
Proceedings of the 11th ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications
The Dylan reference manual: the definitive guide to the new object-oriented dynamic language
The Dylan reference manual: the definitive guide to the new object-oriented dynamic language
Efficient dynamic dispatch without virtual function tables: the SmallEiffel compiler
Proceedings of the 12th ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications
Fast algorithms for compressed multimethod dispatch table generation
ACM Transactions on Programming Languages and Systems (TOPLAS)
Time and space efficient method-lookup for object-oriented programs
Proceedings of the seventh annual ACM-SIAM symposium on Discrete algorithms
Efficient multiple and predicated dispatching
Proceedings of the 14th ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications
Space and time-efficient memory layout for multiple inheritance
Proceedings of the 14th ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications
Efficient message dispatch in object-oriented systems
ACM SIGPLAN Notices
Efficient subtyping tests with PQ-encoding
OOPSLA '01 Proceedings of the 16th ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications
Efficient implementation of Java interfaces: Invokeinterface considered harmless
OOPSLA '01 Proceedings of the 16th ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications
The C++ Programming Language, Third Edition
The C++ Programming Language, Third Edition
The Java Programming Language
Fast algorithm for creating space efficient dispatching tables with application to multi-dispatching
OOPSLA '02 Proceedings of the 17th ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications
Incremental algorithms for dispatching in dynamically typed languages
POPL '03 Proceedings of the 30th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Optimizing Dynamically-Typed Object-Oriented Languages With Polymorphic Inline Caches
ECOOP '91 Proceedings of the European Conference on Object-Oriented Programming
Taming Message Passing: Efficient Method Look-Up for Dynamically Typed Languages
ECOOP '94 Proceedings of the 8th European Conference on Object-Oriented Programming
Message Dispatch on Pipelined Processors
ECOOP '95 Proceedings of the 9th European Conference on Object-Oriented Programming
The Complexity of Type Analysis of Object Oriented Programs
ECCOP '98 Proceedings of the 12th European Conference on Object-Oriented Programming
Compact Dispatch Tables for Dynamically Typed Object Oriented Languages
CC '96 Proceedings of the 6th International Conference on Compiler Construction
Efficient Dynamic Method-Lookup for Object Oriented Languages (Extended Abstract)
ESA '96 Proceedings of the Fourth Annual European Symposium on Algorithms
Efficient implementation of the smalltalk-80 system
POPL '84 Proceedings of the 11th ACM SIGACT-SIGPLAN symposium on Principles of programming languages
Scaling and related techniques for geometry problems
STOC '84 Proceedings of the sixteenth annual ACM symposium on Theory of computing
Software and Hardware Techniques for Efficient Polymorphic Calls
Software and Hardware Techniques for Efficient Polymorphic Calls
Message Dispatch on Modern Computer Architectures
Message Dispatch on Modern Computer Architectures
Implementing statically typed object-oriented programming languages
ACM Computing Surveys (CSUR)
APLAS'11 Proceedings of the 9th Asian conference on Programming Languages and Systems
Hi-index | 0.00 |
A fundamental problem in the implementation of object-oriented languages is that of a frugal implementation of dynamic dispatching, that is, a small footprint data structure that supports quick response to runtime dispatching queries of the following format: which method should be executed in response to a certain message sent to a given object. Previous theoretical algorithms for this problem tend to be impractical due to their conceptual complexity and large hidden constants. In contrast, successful practical heuristics lack theoretical support. The contribution of this article is in a novel type slicing technique, which results in two dispatching schemes: TS and CTd. We make the case for these schemes both practically and theoretically. The empirical findings on a corpus of 35 hierarchies totaling some 64 thousand types from eight different languages, demonstrate improvement over previous results in terms of the space required for the representation, and the time required for computing it. The theoretical analysis is with respect to ι, the best possible compression factor of the dispatching matrix. The results are expressed as a function of a parameter κ, which can be thought of as a metric of the complexity of the topology of a multiple inheritance hierarchy. In single inheritance hierarchies κ = 1, but although κ can be in the order of the size of the hierarchy, it is typically a small constant in actual use of inheritance; in our corpus, the median value of κ is 5, while its average is 6.4. The TS scheme generalizes the famous interval containment technique to multiple inheritance. TS achieves a compression factor of ι/κ, that is, our generalization comes with an increase to the space requirement by a small factor of κ. The pay is in the dispatching time, which is no longer constant as in a naive matrix implementation, but logarithmic in the number of different method implementations. In practice, dispatching uses one indirect branch and, on average, only 2.5 binary branches. The CT schemes are a sequence of algorithms CT1, CT2, CT3, …, where CTd uses d memory dereferencing operations during dispatch, and achieves a compression factor of 1/dι1−1/d in a single inheritance setting. A generalization of these algorithms to a multiple inheritance setting, increases the space by a factor of (2κ)1−1/d. This trade-off represents the first bounds on the compression ratio of constant-time dispatching algorithms. We also present an incremental variant of the CTd suited for languages such as Java.