Improved technique for paging computer memor

Mc Keeman, W. M.

English

NASA Technical Reports Server

General Disclaimer 
One or more of the Following Statements may affect this Document 
 
 This document has been reproduced from the best copy furnished by the 
organizational source. It is being released in the interest of making available as 
much information as possible. 
 
 This document may contain data, which exceeds the sheet parameters. It was 
furnished in this condition by the organizational source and is the best copy 
available. 
 
 This document may contain tone-on-tone or color graphs, charts and/or pictures, 
which have been reproduced in black and white. 
 
 This document is paginated as submitted by the original source. 
 
 Portions of this document are not fully legible due to the historical nature of some 
of the material. However, it is the best reproduction available from the original 
submission. 
 
 
 
 
 
 
 
Produced by the NASA Center for Aerospace Information (CASI) 
https://ntrs.nasa.gov/search.jsp?R=19710010123 2020-03-11T20:50:15+00:00Z
ON USING PAGING
4
W. M. McKEEMAN
CEP REPORT, VOLUME 2, No. 5
June 1970
The Computer Evolution Project
Applied Sciences
The University of California at
Santa Cruz, California 95060
N71 -19598
..
10	 (ACCESSIOUMBER)	 —	 (1U)
ce	 _
(P)kG S	 (CODE)
	
e	 05
 ^rl
(NASA CR R TMX R AD NUMBER)	 (CATEGORY)
w
.,I
C^
CIO
k/c: 4^^'
a qC^
0610 IN ,s
y
ABSTRACT
Much of the utility of paging a computer memory
D
depends upon the ability to execute a program with less
than all of its data resident in memory. It is
suggested that a considerable improvement in perform-
ance, that is, in the amount of Memory needed to execute
a program for a given quantum uZ time, can ^e achieved
by using the dynamic sequence of initial program load
to keep physically close in memory data that will be
accessed close together in time.
x
ki d"-",.
A word is an addressable memory unit; a pjle is a contiguous set
(if' F' -® 2 p wards; a physical memory is a contiguous set of M = m X P
words,; a virtual memory is a set of V 2v words; an effective adUi oa
is are integer F , 0 < F < M ; a virtual address is an integer A
0 < A < V ; the set of high order bits of A
	 Ah = A mod P , is called
the 
"e selector; the set of low order bits of A , A^ = A 
is called the word selector. We assume P < < M < < V .
There is a mapping function R with arguments 0 < A h < V/P
Isuch that either:
(1) R(Ah) is detestably undefined or
(2) R(Ah) < m , and
Ah / A' h
 implies R(Ah) / R(A' h ) .
For any virtual address A such that R(Ah) is defined, R(Ah ) X P
+ AI < M and therefore defines a unique association between a location
in phys i cal memory and the virtual address.
The paging mechanism provides for all of:
(1) Simplicity in allocating memory.
(2) Absolute protection of programs.
(3) Optimal use of physical memory.
(1) is a result of M = m X P . There are only m slots into which
a page may be placed. (2) is provided by relocating programs at initial
load time so that different programs have disjoint sets of valid vir-
1
tual addresses. When R is undefined a mechanism must be invoked to
change R so that a physical address can be returned; the argument
to R is also checked to lie within the allocated virtual memory space.
(3) is realized by letting R be undefined for data areas that are not
needed at the moment. If memory space is allocated for n programs,
the constraint of physical memory can be expressed in terms of the frac-
tion, fi , of the virtual memory space, Vi , which is mapped onto
physical memory for the program:
n
j1 fiVi<M'
where, on the other hand:
n
j1Vi>>M
The Problem.
We assume that the mechanism to evaluate R is economical and
that changing R consumes several orders of magnitude more computer
resources than evaluating R . If the sequence of access of the 1 t
program to its pages is random in time then we expect that during its
run, f.
3
 = 1.0	 As we cycle through the programs in a time-shared
computer, it is clear that if all fi need be near 1.0 then R will
have to be changed often. Our problem then is to force as high a corre-
lation as possible between the dynamic sequence of access and the pages
accessed. The question of how much can be gained is left to the experi-
menter.
2
.
I	 d
A Bnt!rrestinn.
It is assumed that time-sharing monitors will be carefully adjusted
with respect to the criterion above. We address the problem of allo-
cating storage for compiled high-level language programs. Since program
structure will provide us with the means of achieving our result, we
will coi_centrate on highly structured languages such as Algol and PL/I.
Within a program there are identifiable logical segments of data
which can be expected to have a high probability of use for all words
as soon as one is accessed. We present some examples.
Input and output buffers. A buffer is typically treated. as a unit;
a whole record is moved at once.
The code body of a procedure. When a procedure is called, the
instructions are fetched in sequence. Some time is spent within
the procedure during which all program fetches come from the body;
after the procedure is left, no accesses to the body are possible.
A declared array. An access to an array happens only where it is
explicitly named in a program. Typically this is a few places
and therefore we expect the accesses to the array to cluster in
time around the execution of these parts in the program.
The set of local variables of a procedure. Variables can be ac-
cessed only when execution is within their scope. Thus access to
the local variables must cluster between the call and return of
a procedure.
3
I	 1'ip-'R^1	 ^^^'.	 ". ."	 ' ..	 p4 	 Z.T .	 9	 fi< y	 t'..	 `.
s	 ^fi	 w
_y
,,a
The body of a loop. Since it is repeatedly executed, the code
body of a loop gives a highly correlated set of accesses.
The run storage stack. If a stack is used to allocate storage,
typically only a few parts of it are actually accessible at any
given moment. In particular the global and local storage are
most active.
The first step.for the compiler writer is the identification,
based on the language and use to which it will be put, of the logical
segments of program structure. The second step is to devise a scheme
to get those logical units that themselves have correlated accesses
on the same set of pages. It is this second step for which we suggest
an approach.
We have already mentioned that the program can be relocated as a
whole to achieve protection. We propose that each logical segment be
separately relocatable and that the virtual addresses be associated with
the code at first access to the logical segment. The effect will be
to build the virtual space from the bottom in the order in which the
logical segments are first accessed. Our central assumption is that
this experimentally discovered correlation is a sufficiently good approx-
imation to the optimum that the fraction f  can remain small during
an entire quantum of execution time.
I
i
r 3! :. '..a w .,y^*^ Pti
.iOl.il'ieR^^_	 •-^	 . , ^ 4r	 ^ ...-^,^
DVlcmortation.
1410 special provisions have been made in contemporary hardware to
help in the implementation of this scheme. We propose that the compiler
allocate storage for each logical serpent starting on a page boundary
and with a virtual address dl.-joint from all other segments in this
program aw well as the final virtual space to be assigned at program
initiation time. The page selector then serves as a unique name for
the logical segment. When an undefined value of R corresponds to a
previously unloaded segment (detectable by the disjoint address) we
first must discover if the segment has been loaded but this instruc-
tion has not yet been changed to reflect the loading. If the segment
	
s
has not been loaded, it is added to the virtual space and its actual
location recorded in a table. If it has been loaded, the table is con-
sulted and the obvious change is made to the referencing instruction and
execution allowed to proceed. Other undefined values of R are handled
as normal page faults.
Conclusions.
The proposed scheme will cause R to be undefined at least once
for every memory referencing instruction in a program. The overhead
in fixing the addresses need not be excessive (and in fact could be
done in hardware). Nothing said here should deter the compiler designer
from using more static schemes where he "knows" something (such as how
his run stack interacts with paging) or even more dynamic schemes where
he cannot "know" enough (such as PL/I ALLOCATE where a hole can be
left by the corresponding :FREE ). The scheme does not make sense for
5
jr(,rrwr..-, tt','hat need 1(_,200 than a whole pa(.-,e 	memory' . Ov ,:rhoad ca ti,Of
,ii	 L,, avoi(led i'or pro,_,rams that are rw. many times
by Zivirr the loado-I form of the program.
In thi.-	 a.-j iii all that depend oil statistical uffecta)
the t-r .4	 distributions ic e-ential. A compiler,af.^,vrinj- of experimental - 	 s	 #.d
can di0cover the distribution of logical ss oprment lengths (some pre-
limInary data ,gathered on the B5500 pave a median length (if 60 words
for A1jrr,.j programs). The time-sharing monitor can tabulate f and
Y,V.i 	due to various compilation methods. 	 To be generally useful,
such experiments must be reported in sufficient detail to allow their
repetition where compiler, machines or language are changed.
The main affect of the proposal is to attempt to approach the
efficiency of memory utilization of the variable length segment machines
(Burroughs Bj500 ) B6500; B8500) while retaining much of the simplicity
of the paging organization.
k


On using paging - Computer evolution project, volume 2, no. 5

Abstract

Similar works

Full text

Available Versions

NASA Technical Reports Server