# Effectively Utilizing 3DNow! in Linux

Some applications are especially well-suited for 3DNow!, such as graphics rendering. Optimizing applications with a tiny amount of isolated floating-point operations may not be worth the effort, due to the extra time associated with coding in assembly language. There are several criteria to look at before deciding whether to use 3DNow! with the K6-2 or K6-3. First, the application should have at least a few single-precision floating-point computations grouped in one part of the program, as there is some overhead involved in switching into MMX/3DNow! mode. While in MMX/3DNow! mode, standard floating-point operations that use the regular FPU are not possible. Standard integer operations are fine while in MMX/3DNow! mode. The new K7 reportedly won't have this overhead. The MMX mode switch can also break up internal instruction pipelining, which could add overhead. The best way to minimize the impact of the overhead is to use 3DNow! in units that contain several single-precision floating-point operations. Performance will also be improved if the floating-point data is organized in a successive, regular format (such as arrays of floating-point numbers) that enables a series of 3DNow! operations to be performed in sequence.

One application that can be efficiently implemented using 3DNow! is an image gradient calculation (edge detection), especially range image gradients. To illustrate how 3DNow! can enable efficient operations on Linux, we'll be looking at how the gradient calculation can be optimized for range and volume data. In an image collected on a 2-D grid, gradient is a measure of the local change of pixel values (e.g., pixel intensity) at a particular point; in a 3-D volume, gradient measures the difference of intensity between a voxel (volumetric element) and its neighbors. There are a variety of methods for determining the gradient. For an image collected on a grid, one way to compute the gradient is as the directional differences in value of the four immediate neighbors (to the north/south and east/west) of each pixel. When this difference is computed for the entire image, the result is that points that lie on the border between regions usually have strong gradient magnitudes. The gradient magnitudes can be viewed as an image—they look like a collection of region boundaries of the original image. The image in Figure 1 is a range image produced from laser-range data. In a range image, each pixel is a floating-point value which expresses the distance from the viewing plane of the corresponding point on the imaged object. We've displayed the image using intensities where brighter values indicate closer points. Figure 2 shows the computed four-direction gradient for the range image of Figure 1.

In general, the gradient magnitude at a particular point is given by the equation

|Gradient|=sqrt((0.5*delta(

where delta(*x*) is equal to the change in
pixel intensity in the x direction and
delta(*y*) is the change in the y direction.
We've illustrated the gradient for pixel P1 in Figure 3. P1's
gradient magnitude is:

Gradient(P1)=sqrt(0.25*((depth(P2)-depth(P0)) +(depth(P4)-depth(P6))<+>2<+>)).

3DNow! is well-suited to perform this computation for range
images. Since range images can be stored as an array, points that
lie next to each other on a row will appear consecutively in
memory. MMX has an instruction,
**movq**, that moves a “quadword”
(four words—two single-precision floats) from memory into a
multimedia register. This means consecutive image pixels P4 and P5
can be loaded into a multimedia register with one move. If P6 and
P7 are loaded into another MMX register, we can use the 3DNow!
operation **PFSUB** to subtract the
contents of pairs of registers. The result of one 3DNow!
subtraction will be the delta(*y*) for both P1
and P2. One more subtraction can yield
delta(*x*) for these pixels. Additionally,
3DNow! operations can be used to square
delta(*x*) and delta(*y*), to
add them together, to apply the multiplicative factor and take the
square root. The whole process can be implemented using fewer
assembly instructions (and about half the execution time) than
would be required for implementations using standard floating-point
instructions.

We developed the assembly language function
**XYGRAD** to assist in calculating
range image gradients. (The code for this function can be found in
the archive file
ftp.linuxjournal.com/pub/lj/listings/issue68/3685.tgz.)
The function processes a single row of image pixels at a time using
3DNow!. XYGRAD can be called from any C program using the prototype
shown in the code. After assembling XYGRAD with NASM,
**gcc** is used to link it with a C
program that utilizes XYGRAD.