Lecture Notes in Computer Science 4917

Fast Bounds Checking Using Debug Register 101
The general bounds checking problem requires checking for each memory reference,
including references to a field within a C-like structure. Because Boud
incurs a per-array-use set-up overhead, the debug register approach only makes
sense for array-like references inside a loop, i.e., those of the form A[i], A++,
++A, A--, or --A, whereA could be a pointer to a static array or a dynamically
allocated buffer. For example, if a dynamic buffer is allocated through a
malloc() call of the following form
X = (* TYPE) malloc(N * sizeof(TYPE))
where N is larger than 1, then Boud takes X as a pointer into an array of N elements,
and Boud will check the references based on X if these references are used
inside a loop. For array-like references outside loops, Boud applies conventional
software-based bounds checking.
The rest of this paper is organized as follows. Section 2 reviews previous work
on array bound checking and contrasts Boud with these efforts. Section 3 describes
the detailed design decisions of the Boud compiler and their rationale.
Section 4 presents a performance evaluation of the Boud compiler based on a set
of array-intensive programs, and a discussion of various performance overheads
associated with the Boud approach. Section 5 concludes this paper with a summary
of the main research ideas and a brief outline of the on-going improvements
to the Boud prototype.
2 Related Work
Most previous array bounds checking research focused on the minimization of
run-time performance overhead. One notable exception is the work from the
Imperial College group [13], which chose to attack the reference/objection association
problem in the presence of legacy library routines. The general approach
towards optimizing array bounds checking overhead is to eliminate unnecessary
checks, so that the number of checks is reduced. Gupta [17, 18] proposed a flow
analysis technique that avoids redundant bounds checks in such a way that it
still guaranteed to identify any array bound violation in the input programs,
although it does not necessarily detect these violations immediately after they
occur at run time. By trading detection immediacy for reduced overhead, this
approach is able to hoist some of the bounds checking code outside the loop
and thus reduce the performance cost of array bounds checking significantly.
Asuru [12] and Kolte and Wolfe [14] extended this work with more detailed
analysis to further reduce the range check overhead.
Concurrent array bounds checking [7] first derives from a given program a
reduce version that contains all the array references and their associated bounds
checking code, and then runs the derived version and the original version on separate
processors in parallel. With the aid of a separate processor, this approach
is able to achieve the lowest array bounds checking overhead reported until the
arrival of Boud.