01KTP – Microprocessor-based systems

48/32-bit
48/32-
division algorithm

Vittorio GIOVARA
Alberto GRAND
Formulation of the problem

Our goal is to find an algorithm that is able

to compute the residual of the division
between a 48-bit dividend and a 32-bit
divisor using an 8086 machine.

Input numbers are expressed according to

the module and sign representation.
Invariance property (I)

The invariance property holds true when

dividing two real numbers.

In general, given a, b ∈ R, the result of the
division a / b will not change if we multiply or
divide both the dividend and the divisor by a
given number k other than 0.

Example: 84 / 6 = (84 / 3) / (6 / 3)
= 28 / 2
= 12
Invariance property (II)

How can this property be useful to the solution of

our problem?

Since the 8086 processor has built-in capabilities
for handling 32-bit/16-bit divisions, we may
choose k = 216 , so as to reduce the length of the
operands A and B to respectively 32 and 16 bits.

Note that the division by a power of 2 can
efficiently be implemented through a right shift.
Invariance property (III)

A A / 216
= =
B B / 216

Is this result correct?

Are the two operations still equivalent?
Invariance property (IV)

In general, the answer is no.

This is because, by performing a right shift,
we are discarding all the least significant
bits of the operands.

Nonetheless, the result we obtain is still
close to the true quotient.

Example:
184 / 21 = 8, R = 16
(184 / 10) / (21/10) ≅ 18 / 2 = 9
Approximation of the quotient

The result obtained by dividing the MS 32 bits of

A by the MS 16 bits of B may thus be used as an
initial approximation of the true quotient.
The algorithm (I)

The division between A47…16 and B31…16 is

initially performed, regardless of the sign of the
operands.

The approximated quotient Q is then multiplied
by the divisor B, in order to obtain A* .

A* is subsequently compared with A.
The algorithm (II)

If A > A*, then we check if their difference
is larger than B, i.e. we check whether B
fits one more time in A.
◦ If this is the case, A* is incremented by B and
we go back to the initial test.
◦ Otherwise, the difference is the sought
residual.

If A > A*, then A* is decremented by B
and we go back to the initial test.

Otherwise, A = A*, so the sought residual
is 0.
Handling of signed values (I)

The sign of the operands is stored in a

register (which is then pushed onto the stack)
and later retrieved to adjust the result.

This is achieved by means of an AND
operation between the 8 MSBs of the two
operands and the bitmask 80H.
Handling of signed values (II)

Both operands are then made positive by forcing

a 0 in their MSB, by means of an AND operation
between the 8 MSBs and the bitmask 7FH.

The algorithm therefore treats the operands as if
they were positive.
Adjustment of the residual (I)

Note that:
17 / 4 = 4, R = 1 = R*

BUT

(-17) / 4 = -5, R = 3 = 4 – R*

17 / (-4) = -4, R = 1

(-17) / (-4) = 5, R = 3 = 4 – R*
Adjustment of the residual (II)

We can infer the rule from the previous
example:
◦ If the dividend is positive, the residual is the
computed one
◦ If the dividend is negative, the residual is the
complement to the divisor of the computed one.

The residual is therefore adjusted if the

dividend is negative.

The original sign of the operands is finally
restored.
…that’s
…that ’s all
all,, folks
folks!!