Swap Token - Advanced Operating Systems and Kernel Applications - page 101

Figure 8. The memory behaviors of the process which accesses an array of 53 MB and takes the token
in the middle of its execution (left figure) and the other process which accesses an array of 58 MB and
does not own the token (right figure) during their execution interaction.

the phase when the small process started reducing
its working set. Although the process still held the
token, its true LRU pages were migrated to the
large process so that the large one can use these
released pages. The right graph in Figure7 shows
that the large process did increase its RSS size from
this time. Then the large process quickly finished
its execution after the small process holding the
token left the system.
It is interesting to see that the token was also
beneficial to the process that did not own the token.
The right graph in Figure 8 shows that the large
process without the token took about 50 seconds
to finish one pass of access to the array before
the token was set in the system. After the token
was taken by the small process, the one pass ac-
cess time of the large process was reduced to less
than 25 seconds, although its RSS was reduced.
The reason for this is as follows. Since the I/O
bandwidth of the disk became a bottleneck when
a system conducted a large number of page faults
for both processes, the page fault penalty increased
accordingly. When one process got the token, its
number of page faults was significantly reduced,
and it consumed much less I/O bandwidth. Thus,

the page fault penalty of the process without the
token was also greatly reduced, and more useful
work can be done even though its number of page
faults may be increased.

performance of the
Swap toKen mechaniSm

The performance of swap token is experimentally
evaluated using the five selected groups of the
interacting programs. Each of the experiments
has the exactly same condition as its counterpart
conducted in Section 4.2, except that swap token
is introduced in the experiments.
Figure 9 presents the memory performance
measured by MAD and RSS of concurrently
running programs gzip and vortex when the swap
token is introduced. At the execution time of 250 th
second, both programs started page faults due to a
memory shortage. The token was taken by vortex
after then. Figure 8 shows that the once seriously
fluctuating RSS curves of vortex observed in the
original system in Figure 3 disappeared.Although
the RSS curve of vortex does not exhibit the be-