Introduction to algorithms
Predicting conditional branch directions from previous runs of a program
ASPLOS V Proceedings of the fifth international conference on Architectural support for programming languages and operating systems
Reducing indirect function call overhead in C++ programs
POPL '94 Proceedings of the 21st ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Design patterns: elements of reusable object-oriented software
Design patterns: elements of reusable object-oriented software
Dictionary-free overloading by partial evaluation
Lisp and Symbolic Computation - Special issue on partial evaluation and semantics-based program manipulation (PEPM '94)
Fast static analysis of C++ virtual function calls
Proceedings of the 11th ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications
Improving virtual function call target prediction via dependence-based pre-computation
ICS '99 Proceedings of the 13th international conference on Supercomputing
ACM Transactions on Mathematical Software (TOMS)
Adaptive optimization in the Jalapeño JVM
OOPSLA '00 Proceedings of the 15th ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications
A study of devirtualization techniques for a Java Just-In-Time compiler
OOPSLA '00 Proceedings of the 15th ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications
Design and implementation of generics for the .NET Common language runtime
Proceedings of the ACM SIGPLAN 2001 conference on Programming language design and implementation
IEEE Transactions on Parallel and Distributed Systems
Using types to analyze and optimize object-oriented programs
ACM Transactions on Programming Languages and Systems (TOPLAS)
The C++ Programming Language, Third Edition
The C++ Programming Language, Third Edition
Designing and Coding Reusable C++
Designing and Coding Reusable C++
Will C++ Be Faster than Fortran?
ISCOPE '97 Proceedings of the Scientific Computing in Object-Oriented Parallel Environments
Optimizing indirect branch prediction accuracy in virtual machine interpreters
PLDI '03 Proceedings of the ACM SIGPLAN 2003 conference on Programming language design and implementation
Scheduling Distributed Applications: the SimGrid Simulation Framework
CCGRID '03 Proceedings of the 3st International Symposium on Cluster Computing and the Grid
A comparative study of language support for generic programming
OOPSLA '03 Proceedings of the 18th annual ACM SIGPLAN conference on Object-oriented programing, systems, languages, and applications
Reducing program image size by extracting frozen code and data
Proceedings of the 4th ACM international conference on Embedded software
Science of Computer Programming - Special issue on program transformation
Proceedings of the 32nd ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Experimental Analysis of the Root Causes of Performance Evaluation Results: A Backfilling Case Study
IEEE Transactions on Parallel and Distributed Systems
Collecting and Exploiting High-Accuracy Call Graph Profiles in Virtual Machines
Proceedings of the international symposium on Code generation and optimization
Online performance auditing: using hot optimizations without getting burned
Proceedings of the 2006 ACM SIGPLAN conference on Programming language design and implementation
Accurate, efficient, and adaptive calling context profiling
Proceedings of the 2006 ACM SIGPLAN conference on Programming language design and implementation
Whole-program compilation in MLton
Proceedings of the 2006 workshop on ML
GangSim: a simulator for grid scheduling studies
CCGRID '05 Proceedings of the Fifth IEEE International Symposium on Cluster Computing and the Grid (CCGrid'05) - Volume 2 - Volume 02
An Introduction to Design Patterns in C++ with Qt 4 (Bruce Perens Open Source)
An Introduction to Design Patterns in C++ with Qt 4 (Bruce Perens Open Source)
An extended comparative study of language support for generic programming
Journal of Functional Programming
VPC prediction: reducing the cost of indirect branches via hardware-based dynamic devirtualization
Proceedings of the 34th annual international symposium on Computer architecture
Code Compaction of an Operating System Kernel
Proceedings of the International Symposium on Code Generation and Optimization
Backfilling Using System-Generated Predictions Rather than User Runtime Estimates
IEEE Transactions on Parallel and Distributed Systems
Design patterns for generic programming in C++
COOTS'01 Proceedings of the 6th conference on USENIX Conference on Object-Oriented Technologies and Systems - Volume 6
Improving the performance of object-oriented languages with dynamic predication of indirect jumps
Proceedings of the 13th international conference on Architectural support for programming languages and operating systems
Inter-operating grids through delegated matchmaking
Proceedings of the 2007 ACM/IEEE conference on Supercomputing
On Simulation and Design of Parallel-Systems Schedulers: Are We Doing the Right Thing?
IEEE Transactions on Parallel and Distributed Systems
A language for generic programming in the large
Science of Computer Programming
Harmonizing classes, functions, tuples, and type parameters in virgil iii
Proceedings of the 34th ACM SIGPLAN conference on Programming language design and implementation
Hi-index | 0.00 |
Generic classes can be used to improve performance by allowing compile-time polymorphism. But the applicability of compile-time polymorphism is narrower than that of runtime polymorphism, and it might bloat the object code. We advocate a programming principle whereby a generic class should be implemented in a way that minimizes the dependencies between its members (nested types, methods) and its generic type parameters. Conforming to this principle (1) reduces the bloat and (2) gives rise to a previously unconceived manner of using the language that expands the applicability of compile-time polymorphism to a wider range of problems. Our contribution is thus a programming technique that generates faster and smaller programs. We apply our ideas to GCC's STL containers and iterators, and we demonstrate notable speedups and reduction in object code size (real application runs 1.2x to 2.1x faster and STL code is 1x to 25x smaller). We conclude that standard generic APIs (like STL) should be amended to reflect the proposed principle in the interest of efficiency and compactness. Such modifications will not break old code, simply increase flexibility. Our findings apply to languages like C++, C#, and D, which realize generic programming through multiple instantiations.