Storing a Sparse Table with 0(1) Worst Case Access Time
Journal of the ACM (JACM)
Self-adjusting binary search trees
Journal of the ACM (JACM)
A fast method dispatcher for compiled languages with multiple inheritance
OOPSLA '89 Conference proceedings on Object-oriented programming systems, languages and applications
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
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
Time and space efficient method-lookup for object-oriented programs
Proceedings of the seventh annual ACM-SIAM symposium on Discrete algorithms
Space and time-efficient memory layout for multiple inheritance
Proceedings of the 14th ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications
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
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
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
Efficient dynamic dispatching with type slicing
ACM Transactions on Programming Languages and Systems (TOPLAS)
Two-dimensional bidirectional object layout
ACM Transactions on Programming Languages and Systems (TOPLAS)
Perfect hashing as an almost perfect subtype test
ACM Transactions on Programming Languages and Systems (TOPLAS)
Implementing statically typed object-oriented programming languages
ACM Computing Surveys (CSUR)
Metamodeling semantics of multiple inheritance
Science of Computer Programming
Hi-index | 0.00 |
A fundamental problem in the implementation of object-oriented languages is that of a frugal dispatching data structure, i.e., support for quick response to dispatching queries combined with compact representation of the type hierarchy and the method families. Previous theoretical algorithms tend to be impractical due to their complexity and large hidden constant. In contrast, successful practical heuristics, including Vitek and Horspool's compact dispatch tables (CT) [16] designed for dynamically typed languages, lack theoretical support. In subjecting CT to theoretical analysis, we are not only able to improve and generalize it, but also provide the first non-trivial bounds on the performance of such a heuristic.Let n,ml denote the total number of types, messages, and different method implementations, respectively. Then, the dispatching matrix, whose size isnm, can be compressed by a factor of at most ι ≡ (nm)/l. Our main variant to CT achieves a compression factor of ½ √ι. More generally, we describe a sequence of algorithms CT1, CT2, CT3,..., where CTd achieves compression by a factor of (at least) 1overdι1—1/d, while using d memory dereferencing operations during dispatch. This tradeoff represents the first bounds on the compression ratio of constant-time dispatching algorithms.A generalization of these algorithms to a multiple-inheritance setting, increases the space by a factor of κ1-1/d, where κ is a metric of the complexity of the topology of the inheritance hierarchy, which (as indicated by our measurements) is typically small. The most important generalization is an incremental variant of the CTd scheme for a single-inheritance setting. This variant uses at most twice the space of CTd, and its time of inserting a new type into the hierarchy is optimal. We therefore obtain algorithms for efficient management of dispatching in dynamic-typing, dynamic-loading languages, such as Smalltalk and even the Java invokeinterface instruction.