Moss [14] describes one of the first studies of different address translation approaches, and the associated terminology developed for classifying these techniques. The primary classification is in terms of ``eager'' and ``lazy'' swizzling based on when the address translation is performed. Typically, eager swizzling schemes swizzle an entire collection of objects together, where the size of the collection is somehow bounded. That is, the need to check pointer formats, and the associated overhead, is avoided by performing aggressive swizzling. In contrast, lazy swizzling schemes follow an incremental approach by using dynamic checks for unswizzled objects. There is no predetermined or bounded collection of objects that must be swizzled together. Instead, the execution dynamically locates and swizzles new objects depending on the access patterns of applications.
Other researchers [10,12] have also used classifications along similar lines in their own studies. However, we consider this classification to be ambiguous and confusing for general use. It does not clearly identify the fundamental issue--the granularity of address translation--that is important in this context. For example, consider pointer swizzling at page fault time using this classification. By definition, we swizzle all pointers in a virtual memory page as it is loaded into memory and an application is never allowed to ``see'' any untranslated pointers. There is no need to explicitly check the format of a pointer before using it, making pointer swizzling at page fault time an eager swizzling scheme. On the other hand, the basic approach is incremental in nature; swizzling is performed one page at a time and only on demand, making it a lazy swizzling scheme as per the original definition.
In general, a scheme that is ``lazy'' at one granularity is likely to be ``eager'' at another granularity. For example, a page-wise swizzling mechanism is lazy at the granularity of pages because it only swizzles one page at a time, but eager at the granularity of objects because it swizzles multiple objects--an entire page's worth--at one time. As such, we contend that the granularity at which address translation is performed is the fundamental issue.