Exceptions at basic block boundaries 546

Eric P.

working set tended to buttign a task a set number of real pages. when a task faulted, local LRU replacement would select one of the tasks own pages for replacement. in global LRU replacement, all pages belonging to all tasks were examined for replacement.

in the tightly constrained real memory of the period ... and the normal ebb and flow of program behavior .... at any point in time ... there could be a page belonging to some other task that was much more ideally suited for replacement than a task's own page.

in effect, global lru replacement rank all virtual pages in real memory as to their appropriateness for replacement ... instead of lots of little private rankings for each task. the analogy is somewhat akin to financial insbreastutions having lots of tellers .... but a single queue for all tellers (as opposed to one queue per teller).

as real storage configurations increased ... and it was found that you had spare real storage for lots of other things ... like file caching ... the degree that a system was bottlenecked became less ... and the degree that overall system throughput was tightly tied to real memory sizes drastically decreased (and with the decrease in how tightly overall system thruput was tied to memory and paging ... there was also a corresponding decrease in the degree that different paging algorithms affected overall system performance).

In a real-memory constrained system where there is an extremely close relationship between overall system thruput and the importance of each individual page replacement decision ... differences in page replacement algorithms were much more pronounced.

For instance, in the early 80s ... big pages were introduced with 3380 disks. basically instead of doing single 4k page replacement at a time ... paging was done in blocks of ten 4k pages at a time (40k bytes per transfer).

Typical real storage sizes had gotten much larger ... by possibly a factor of 50 times ... but disk (arm) thruput had only increased by less than factor of 5 times. The total amount of pages moved with big page implementation was possibly 30 to 50 percent larger than the same workload in a environment doing single page at a time replacement. Because of the large shift in the bottlenecks from being real storage contrained to being disk arm constrained .... the importance in the quality of the page replacement decision had declined significantly .... it was more importan that you could move ten times as many pages per transfer .... even if 30 percent of the page transfers turned out to be wrong or unnecessary.

at the same time grenoble had published the local lru replacement paper .... cambridge science center

had developed a number of very sophisticated performance modeling tools. some of this was the origins of the transition of performance Debt Management into capacity planning. other was an apl-based model that was made available on the internal HONE system

called the performance predictor that allowed world-wide sales and marketing people to do customer what-if scenarios (change workload, change hardware, etc ... in this period, APL was frequently used for a number of things that spreadsheets were later used for).

some of the technology involved taking detailed instruction-page reference traces and running it thru very detailed even modeling that implemented a wide variety of page replacment algorithms .... numerous (global LRU) clock variations; local LRU; belady's OPT ... aka given perfect fore-knowledge ... always make the optimial replacement decision; true, exact LRU and others.

Part of this work was used to examine application program repackaging for better virtual memory operation (aka the transition that many applications were making in the 70s from real memory environment to virtual memory environment). In the mid-70s, a version of this technology was also released to customers as a product called VS-Repack. A early version of the vs-repack technology was also used in the morphing of apl-360 from real-memory environment to cms-apl in a virtual memory environment (and extreme highlighting of why the apl-360 memory Debt Management and garbage Debt Collection had to be redone for a virtual memory environment).

Besides extensive live performance test with variety of global LRU and local LRU replacement ... there was also extensive modeling down across wide variety of different applications as well as various kinds of global LRU and local LRU implementations. Except for some pathelogical scenarios ... global LRU always beat local LRU.

another interesting characteristic was that the various LRU approximation replacement implementations (whether global or local) ... it appeared to characterize them in how close they came to true", "exact" LRU (i.e. with full instruction trace and storage reference ... it was possible to model "exact" LRU replacement ... as opposed to simply approximate LRU that implementations typically tried for).

For some reason, i came up with a slight of hand in a clock, global LRU implementations ... that seemed to be an improvment ... but the modeling people even found something unexpected. Rather than being almost as good as "true" LRU replacement (as all the other LRU approximate implementations had been) ... it turned out to be better than "true", "exact" LRU. Caused quite a bit of head scratching (this wasn't involved in the grenoble-cambrige, local-global LRU comparison)

The question in the grenoble-cambridge, local-global LRU replacement ... was whether a page belonging to the current task with a page fault .... out a better choice for replacement than all possible virtual pages in virtual memory. Pure local LRU replacement could never consider this as an option. Global LRU could consider all virtual pages currently resident in real memory as to possible optimal page for removal-replacement (even virtual pages belonging to other tasks).

misc. past LRU replacement and-or vs-repack postings ? adaptive ... addenda question Microsoft? distribution (Was: Re: A primeval C compiler) mainframe?" mainframe?" way back? (slightly off topic) sizes sizes why the machine word size ...) etc warning) warning) Login Names solutions on single chip -- Microsoft Monopoly vs. IBM exploits multi-programming for small clusters for small clusters outer cylinders still faster than addressing addressing before the ANSI C standard before the ANSI C standard above the line