Amortized efficiency of list update and paging rules
Communications of the ACM
Garbage collection can be faster than stack allocation
Information Processing Letters
The input/output complexity of sorting and related problems
Communications of the ACM
Improving locality of reference in a garbage-collecting memory management system
Communications of the ACM
Caching considerations for generational garbage collection
LFP '92 Proceedings of the 1992 ACM conference on LISP and functional programming
Improving the cache locality of memory allocation
PLDI '93 Proceedings of the ACM SIGPLAN 1993 conference on Programming language design and implementation
Abstract models of memory management
FPCA '95 Proceedings of the seventh international conference on Functional programming languages and computer architecture
Parallelism in sequential functional languages
FPCA '95 Proceedings of the seventh international conference on Functional programming languages and computer architecture
Garbage collection: algorithms for automatic dynamic memory management
Garbage collection: algorithms for automatic dynamic memory management
Using generational garbage collection to implement cache-conscious data placement
Proceedings of the 1st international symposium on Memory management
External-memory graph algorithms
Proceedings of the sixth annual ACM-SIAM symposium on Discrete algorithms
I/O-complexity of graph algorithms
Proceedings of the tenth annual ACM-SIAM symposium on Discrete algorithms
A provably time-efficient parallel implementation of full speculation
ACM Transactions on Programming Languages and Systems (TOPLAS)
FOCS '99 Proceedings of the 40th Annual Symposium on Foundations of Computer Science
Algorithms and data structures for external memory
Foundations and Trends® in Theoretical Computer Science
External-memory computational geometry
SFCS '93 Proceedings of the 1993 IEEE 34th Annual Foundations of Computer Science
Space profiling for parallel functional programs
Proceedings of the 13th ACM SIGPLAN international conference on Functional programming
Algorithms for memory hierarchies: advanced lectures
Algorithms for memory hierarchies: advanced lectures
Practical Foundations for Programming Languages
Practical Foundations for Programming Languages
Hi-index | 0.00 |
The widely studied I/O and ideal-cache models were developed to account for the large difference in costs to access memory at different levels of the memory hierarchy. Both models are based on a two level memory hierarchy with a fixed size primary memory(cache) of size M, an unbounded secondary memory organized in blocks of size B. The cost measure is based purely on the number of block transfers between the primary and secondary memory. All other operations are free. Many algorithms have been analyzed in these models and indeed these models predict the relative performance of algorithms much more accurately than the standard RAM model. The models, however, require specifying algorithms at a very low level requiring the user to carefully lay out their data in arrays in memory and manage their own memory allocation. In this paper we present a cost model for analyzing the memory efficiency of algorithms expressed in a simple functional language. We show how some algorithms written in standard forms using just lists and trees (no arrays) and requiring no explicit memory layout or memory management are efficient in the model. We then describe an implementation of the language and show provable bounds for mapping the cost in our model to the cost in the ideal-cache model. These bound imply that purely functional programs based on lists and trees with no special attention to any details of memory layout can be as asymptotically as efficient as the carefully designed imperative I/O efficient algorithms. For example we describe an O(n_B logM/Bn_B)cost sorting algorithm, which is optimal in the ideal cache and I/O models.