F2^
e.a-. .f-' /.-
pJ'A
f-'J
cara..ttt/r
/O+aA1
'rm*n'/Aa
u^
,t>lhjz .rn V /gt,.-r
.&
o.:zv,
r"l^r.
lutrz'
r
/4a
rn--&
en*q-"*t
,
J
zea
*Lt":
Fa
rrn"
rt"ilt*4
,rrn--^/-
|
+ lzv
J
b
lL,?
p-^'e alzzx,t'. /on !" f*
-/""-#^/
,
,m o!
)cu .on'*t:h^
J
ftr/' *>,
tt/+,^
,'f
/r42. ,
p
^//th//
h
".-r4r.,f-,
a
/. f4
Prtl.<,- a6rl TT c^
V,&'/*t
,l a4b
qr{t^dk
F
c:nof
,A:^-
/"i^
+*
Fp" frn-oJ'"
$t_
/r4o./^otor'.
-"*'r*,1;,1.'o"l
F
*- n^
!tf'F"
,l*
f4Vt^
/
,+?^
,nJ*uJ
rL
.,/"., t.* ,L
/n
P^/r..l
yr/.*3./^
u- inct^o*
7,"'olzl
c; - 6,&or^ at/ e-tc'Va.r4P4t-Lpt:L
(tzcae'u,p)
/:-
T-'a;,
& ,*.
*tlt p"rt.u,n
T
/'
/*
-
^f:6":J.,^
F-
+f
(
&t*j'*
A3
/t^
po,/o-'* ra.t l"*7-"'J.,*. t-, o2 u'#y
,'J ,-/ co*p-
4ng,tr4
6&oa /./ n4'
*
fry 7gttr?-
(z'tuQno
2 u'44: /aaa'<L, u**o.a.,
tc-e<4,12
Ctttt l
/^
aJ
)r---
J
<43
R,
LEb
,Q=
=
Soon
's.o-
Le
-o'q)v
tt/,mr'-..*J^
'rr
;i
-
/)rre it.
-
z
o?of-
rtf.t^o"-*J
y'a-
e',*ea$z
7:,..2.., l:a'6e,o A Lene_zA
3;
F/euc.o
6.- caiTqd sa/Dls o ca<7Q /aapTo
F/<te.,o
5,- Oot'T
m Po& sut
{r..l"^
c& rnarr.F,u..t ( .i"
"r-ru)
VaJ.*' ch /(Jrc^
"e,&
n la
*'"ni^ L',./t^.
CoAtC7A tuLf P ot ENipAAs v EL asza enlo
fr.V<<
=.tSV
r'
I
t2.8
|
,ntA
i
V
I
(o)
I
<o.ll
're^
4
,mar{"'u1
,L76
t-
r*-
i
ll
! ru,-l
L
J
R
4i1.2
Ir'll
;-
(
tto)
--l
I
I
t
I
I
I
I
I
l
I
I
I
i
I
I
f
/6irP.a 7,
-
as'/|-rQ s/>A.S
CC,VCAAC
,o ba( NTr?lraf
_-+
f-
+
I
'
tNacc742 i8/,<7a
aJ afribo ALTO
=15V
t-
RZ
/. G, tZo
lr.r,f
&2
(sr)
a4
(xo)
DI
L<_ !__
J
I
i
I
I
j
I z.x
,lA
;i .lc,
fJ't'^l { tcc{cu c;-p,{*, & *t". o&ot6
F
/u.n
ccrl
(1/,1^ po/-
a-itt",tl
'-
L
Vic
.
,J*
.,*
^Jj*
l- /i.'.- Ja-6o,J-. I af.* u,'.
P',.
lD
l.',)*
/* p.L/"-
Jit-rr,/- ,uln ,^ L'T/ p.
,*L.*
.t/a" /.n
,eAat-
t /rv c.>nt<uvfet
-J"*azras.
co.Jyrur.
4J. .y"u
7oo.'
,J {^-J.
e/l ld
e
pot'","*t
y^- pn1.4r ti
e"la
oy'**.rr/'-'o*
ti.J i-rc,.
o6t+tt.,-
1ru
/- r..
.JoonJ-
-.f--,ru"-l3ota-e
('rt
ce'rf<r,#
sJrL cL 7'*t Pc'.
D+ nz't Tdte o4/o-no-/r
,/
c: ,'-4.n
'/a
Lcr- .yt,o.tt
u*rL*
--
fu.(
c.nc+er
oJ
t,t tt-t
"uLfr.1,
a..L
*oY*J-
/^a
f'2iutc
S ,,ut'rt'y- ttf-
*Et-c'' .'.--,/-
r
u<<i
" <*,,-nArl".
El voL/4< - p"Ar/:ox,rz
cL
y'o"lens,in*rrr/ot*-
P ,l
L
tnr:,n*rb.rro
co,,XL.L,*/
''f.u,'t-7to",ur
L1 t J,urr/-^
o4 / I a /.5v,
*u
"-Ll?,
/;gr.
,'"-
ea /.
l^^L,
/,
il*
tt c, *ch aLrr6
f-'J,
LLru'.vr1
/al,a P.t.v1
h
l*
c/ ,",-oi; /,;f*t"^'c;'zmln
7/"u',*-,;)
u,
g'.f
cu,tu*-. FJ u,JS*", ,n.r" J* /^rfrl/ot d<./
Ba*" +r+?tt
L'r.L
tt/.t o, i o#*L
Acrg . /o c*r.'.r,*
"*,,
o edl
- J r-1.'
1c7
.-
P'-n:
/ Bqs'
u J ofu
Bao,
/F''*1
"*
4'a')u.e h.'..^.-..'trn
au J r to, o ":fa
f.t
8us-
,ta- ,-ur,-6
"{ut
c&o/ p/L;^ J
ot'p.*tw
7a-tala
dJ*
^&
tdip*,'t.
/nrrna,-rFo
eo,
J &- o,
h"
'.-r"nu.
,A L!.a.rt
tttt- ,/t"-;
,7-7rJ- J ,'24, ,' /o p*r-**,'c.'..
V"
, /*
7/,.no,,,a
&
oL.h o&ert. * la<.r/ar'c"i/r.Au'
F,aabf*
4"volntnTront4o I
14 <'o..'-t"
V6
3, f5V
).--
-
-l
V'r'?-re;
R
/.6,-A
-f
I
Y.
t.
t'
r_
t--+--J
t--
(".)
(*)-
)
zsr
TPA
tr'
lCu<t;
itnno
i ll',,*
, , ',
.-4'u,,tJ4 a/tr? r, e;ptfaU"^t":41aZfar.$fi1
pn,/*t&
.
, .
J<^trg$),
t-,;i
dt&n
4rcuL
1/a'e*.<t/'/ &
"J&
".'
"
'ntu'
Pll'xmd : /n oo-'/o
vol*
^
tr"' ol, R
n J a'4/"J. ALTI
,-&
*** L.^
ftn
o[?.*
-Vr,
,-?
fl+
^&p.'/L
o,*1'*',,,.""."4- (z-tv
pL^
!^
TT
-e^,.r'"Q'-'
Ed^ ea//.^
ee
/*tz.
pn-t^ p,r,L-
ifg^', ^
/'A " uy'oJ /1Lru L c,-,fi.n .-..bL-*.'
.
y'"n
.#,
/?,8a.!
,e
cr.^t'.
f
Je
alt Zn o'.'t
/,
Jn-..tu
t-,.t 7
a'nnu.fur'/-
er.firoJt rr .li/o'r-
. Ccnt-u
I .*.fio
,^1^
fr'.-r^
6, lneor.rent
a lrnvt
d, .4
7*r^
fiama-r<.cza'c
/""'.h- cL
4Ln"^
,/f.'l'c^.
-a
/6r-'A,
t*
f-.A
,P,
rrror/"
V*
-
zR
=
Q6-z(t-c'''-,o
=
/z.g,nt,Q
/on L
An
I
'^/*,
.,ni*',,,.
,Q *{ /^-/"
F^..
,4
=
{s.o
-a.o)v
?pe t z.
-
s c r ' b'u,-e,4 .L
:f-"L
, /r*/tJ
-
WX z4 F
=
352n
F=
r43
+
fl
+
ftlt ti,s
* Wt |r+ +1r
r : frf
|
+ xYz + w i Y
7 +
wxi
i +
*wX f
z *
wxY2.t *r YZ
ZR
e?;,U.?1
to. v,Ly'e/<
,*'/^
&
a.oV
oq ug 4 .1Y (Vo.nr*)
u
f'^
c4 a&,, J
/u*"!AL
l
f-,1
cz, ,'t
(tt"^h
-t
.tur*
/^
/".L'/^
e.-d.
^.o" ^y'^
1.,'-t
tu P'J^
r-nt-.'
c*"-/"-^ ,/
v'd'a t d'ov
(e'A ci
/n'aax)**ia
a'?V),
n*t
datzrtt-r
)* F
Cot<aa
.m*t & /6 m.A,
/aro 4*
,roo A.
fr*a, 1, .ac
-
d,.---""
t^/-*
f*1.e4
e4el O.qVt
Vr*".' 2.u t'/^
pol&
^-la.n
&.<-ao
ut
6go
.1 &t
^'
rr'"s
& d.4vt/
L
a-P.zt,a'(+r.tqtt ,znoi 4 /6,q4/-rca.rf.
l0
ld
to
0
/t
tl
lt
lt
l0
ld
0
0t
0l
0t
0l
o0
ol
t6
t/
oo
o/
td
Y
40
ol
/(
t0
tr ol t/ la I
a6
^rt
t2
il'
ry
t 4
tltg
rt
,rl .t
llz
^
r'l I
!4-
,)
,r/
,v
ial
,,
I
',
4o
/--<
F= VX+yz
F=YJXt/Z
*
J nJ^ mzdxtt*
tta"*'64
7a-zn
R!, *,
y'-
1*"-d^
*J*u',
-f
lrt-c.."
l_
)'
7
wx
66
ol
Ir
t0
o) lt
.40 It
)i\
YrA
{r4
^rf
fi\)
rl
fu,
Y1
rrit
-
I
i'i
l
fi{.(
,)
ntr fh
\urr,
lrl
f
l
WX
'tz
PRoBLtt z,-
j
a.)
x
(?,*6.lzn^ l)
|
&9S'..
)c4 e
ftiJtze,u
r,4
,r'ra5r6{
.ozr.4 1
esl-/"
ALTo c4 o'7V.
El 71
SaJ
b?.,*'/dn ,tur-'.'-.".tnt *J"n
u, L &''t,'?..7?1s cf-rlo-r
(
/.5 ,,
,,
,,
4
4.*
Zo!
ry.*
*
/?o1
,
,^o
ca ry,,+',*-
d'
f-*
y
4t ?-^
.4',L
n h t',*'-c-f
/ nol.r/^ .-r1 ,l ,"/."
ALT2-
papTE
Z.
-
BpU feoeia
E. / N/ VeLES Lo'alco.r
/
uy'eeates
E Ruia
le Ca^a.-"tEa"
Q
7tau-/cat**c- & ,t"J* p'/* 4 ur- c"..f..r-v
i 'atatl'a,'-
paUO
TTL
t condlao*a
fr'q),a
*
autzeh- u,
y'*
fi*t*
2.
E^ atf^ -ot('z-
+/n /-
*{^i';r/'T'-h*
4J
.L
*
p,o-y'-o
('- *1,,
rfutatu
)n,
e
-z
0
0
U
o
d
0
0
0
o
s o
o0 t
ato
dlt
/0
0
/d
I
/
tll
t0
l0
0
0t
l0
l0
t0
ol
F/6u< I
V.
,y
a",-,fr^
"47
,
4'A
d l^ ea,"Vt'la' 17
a"/^ co c.-'a
',
&"' ercc'r-,r
a /, fu^,
p/r,,,r-t
dtf.n^ tt).
t.>4
gFI
7T C>*zc aa/;u..r"
Vd* au-r-t at
/. 2,V
J^
u, .tt
,o'i
aTd cttn-
"rrJ2u.z^
df"/ n?..+ 4 sV, s.
,
ir^.,,4 A
^nirJ* tni{ ,'f" L?VJ /.sv A ,,fttr*
7*bt,
.u r-t(cn<cr,) y'v.cr',
i...ai'.Je,#*,..o'i.4.,V,,4.),,',e:')
"'o I \
.7a41 ar.^lLa, u,,,
fa+,z*.t
d.r*/,-'.'2rrt /*
ar4. ,r'"
,bSn'*.
l, 't"J:
-/
pJ/* tp.r., ,l ,r-o*
c* n(nJa
J
pJ/* tpv.' 4 u,.L a;
/"4ea/
ox) &o,o,r/g^-.
E{a
u-&u?
orrpqtf^
r.+tr4t.(<n^ TfL .n,rrr-.|*
"
d,.-,.h .ru/.u'orrlol
.ar.*n,.urrbc/t
tmvad.o^ 7TL
_
ntt-.{*
t1
f-4
"rur/'o',orio4
pr.*o.,u&cl
tbA
-
V' ?42/ lc'"iun'iua
ca'4;'z t- 1o
P.'y','/^.
'1o
t'O
t
c*r-zf.tHF;- &
-taa.<afuut.e
f
a<L uz.t.a.t
I
Af*>,,
"e
c.ra.,/-
/.- *'*.^/"
,,/
, 4 )_ *ry?
.
!,.
*"e;
,+_; c ,n4az.
,&
r'n;- c/, '.1; dor"
pn
1*r'
7"' ca,aTat#*t i.J*
olSrur-" 'oo
,o.
&onru
.J
/o /u./r.r.'-r-l'*
I \
i;ft;;';;:f-,:;;;;2,to=
i \ <,
.+tr<r A.',0',
d' ,n
p/<r.z
*-l1Jonrru'
,.=
*o'r,o,
/-u
?*r .-,-,r*
.1.t
Fn
uon
-
, a, , .
t,z t.S .z-
l,
5.e
*a Vafulatt d. {- <"- ctQ
7ma/,r.zczz,n
/'a
etlotc^
,^o;lr/*
&
1" /',r1
)r11t+/4
.1^
1u."
/aga..."t-l
r*Vr.y't^zranea o>.tcaaSey't/a
&.,t*,'ct
8l7d
jr
y'Lra . ,/o"
Qto'r-o.'uo
.r*urJoon'n
/u^'Trz
o-/./,r
F
,>ttzt#.tzn
n /*"r/,.:ru.
/a.
Ft
(u/2
/ d,
-
l,t V h k..c",- fTL
\1
Yor
r,n
ntr*'u
.4 pcur.'..uh. Yrhn*
y'r.rnf.
,/a/rfu & *lno/-
,aru,'tt.t
&1-rr4"; /oG-
p1
tu.c:tza
o 14
ct*u
ttq
altd- 8A7o : A,8V (Vttrn"e74xx-raa/a-f)
fe+a-
t*ta 77/,
of"/"".
Yz*nu *
J r"Al"<
t+t',,w',tu..
j*,"^tJ../.
/:y ret
/u--?rt<.^'
c.'rrt-
o*A,"
y'-7d
-
2-.'V: YZt
-r.o
-
a,o'/'*o ,{
/o e.a/,v4n4A- u4 pJ'oG .
1^
ALlO
sre tc ALTC
+, /1 R6 ar .y' R:;o CD
A Ntrl'rlAL
Fluan //,- //tvql-s
zl<. <.s-
/ ,<.t/rsotx
,
-laly'a 77L
c c>nffifa TfL
//^drr..
/".r
7an*'.-*lt^i
rn 2 :
sTv:$Alo_. r, ) , , , ..
.""i1;frii"-c
Vo.,rn^
eo J nlhtrV ,,7t/. tm{*,'.+,t',
n
J
/rA
+r'"-J"
8/J74 ;
A,l V
/*t^
771 <sla.hdo.,,If
u
ca
J n44 c p,rl.",L .*'.*,',rzq) tn
J aof-J.
r'lTo, : i.
q
V'- 7.4r /,,
7orro,,;orr-Zu,
& 1-
fl[ztre
/ t1]o;
ot",*tg.-J,
p^
Lt
*6a-con,
c4 rrl
/t:
t n,4a,J."{. ltmVza.lu,.t..-.
fur:.*b
,tl,
V"e/*
J
c:.Lt):,.1'
..id-.
'
/4 ti,8v Vrr.**
"-z
zA ,
%a
*n,
p:0 o,a//
a->L'
lctt
zzna 77L
^tir,
,.,,,4;tH
/ ,uu-d- ,/r'cD
"';4{n J r^4'oro ,
t4*
nzaas..t'o-n
ol ,nrz..r d,1v -
r1ud?
,f*,o
di"tlg'"nru o?-
pJ/^
Oa7'<t..
"n
J
fia
<a.u/
p-yn*
,4,
arctt+Ljzrs1 )c,<
t-2.,t vo#4<'
,*^
,u-.o-.L.L
cnL u^-
"r.i/n.-r^
zt
.
a."u=r,
Ag u"-nnat)ctt & .rw^'/-,
a'
'#
A.|V ,;n, J t"/. /tL-d.
vtu
vn
VzHrn^
vrH*ru
vog
L=,
[o'rv
(ov
'LHA^
f'"
|l3.*u
.9P L,r A a
-T'irtnx
H.r,
ia
'r-rJ.-{.
&.
/- .nnzt-r.z/J,rjn-.21
& u, a',n utt
O
r/"n*.-- nap;eJ xc-eg;u
7 p ;rVrreao
en rLhr
. /tat^ r.x cLt
-
.rte',na/- A,u<.r.r.
/4
coTtk.
h.ca-rc
a/qlt
Vi,,t o
,-*rJp, e
,zt*,
rt , na-,gruad
rt"/.
/q ^
4l7r* atTa
(VAr)
f
cmceg.ta
6
aza'd,
f**
r+uv./ /7c
(Vr"L,
-5-
tplre/
I ltco
AL74
Le'1 t
A4Ja
I r 6rcc
ALTA
Yrrrrr,
Vot l'a-+i
tcv Vt n,r.
E-b;: i t
.+
|
"*+*.J..ttA4ain*Af
tt
n
4"1'^o
*.4r,i,*
l;
fu'
=,.Viuii,,)i,
)
B'/o ,.', J
-
,o zp{o
{ n+Vc/ Ytt
vn,
=
vztrox- uoz,-;r
VAUT
(z)
\ J t+t ,yt^cL
rxcz,tu> Eo.t q,o /- ,"f^/o
pa-
ottt-vtt,
?,2
Vr*^rr,
y'^
pal.f,4ucrer,,
)*
/ra..1
tLu at'ytf,
Ata
^
e/.
,dnJlpop.rr&
&
".,tY.t"
^
/L
,
Rc5*'m
d
t-
1*<.tv*CaP'*+t
'
rr*,
.u/t -
L4
-*' sa /rn,'/" zyc.uo /t*,
'uu
l^ urfrJ*
,/ /4^ /!orT
Urru.
-
2.
frnl-
prr/,
ucrecr-
|f
-!U
f
,.r;i!'; i
B1
,'^"
1
na7*a/'
u
2t^.n,
Vzt
+/t<r -1
,*'t
,n J
{**,.n,u'-'-A-
,/.
y'^
fe
-{)-
-/
\
\
Puo+or"f^ d 1*
f-rt"i /, nz,,'J,
*
u,m pt'at /, n -'4
0xcitnt
u, /n ,.^y'<.
--
l1W';e.7,
d- ll-
nl^#y'n.
=
,0L
'/
ur.;/. o %-
-----
&u**&tTc'-"
r--.-
^.-.
J,
tri
,*co
o&
y' /t'u*a-
Pxccs/uD
6,
:i
SAL'AA
:
isY
lq-qv
i'
l.".
3.sv
I
I
I
I
I
I
(o.tv
urtl
*
(b)
vz,t
{op
vtx
nLt
Yaxn,,,lUru
VcLmex
You
tt*
NAN
9t
4,ltalz
+ 3,3Y
vr
_6_
-spl/"
7,
m
oca4.,4l2 A
rat
Sr,u
J an5;t&
r-r;
Ft
Y/noa gqrr? urF 42'& Yge
'
,4
prntn o 1^
.o,';';, , F*th
,c
-, t;
Yon
^
/" a/'/t";tt' *h l^
F' '
't'o/
ralz
7tt*tt
et
ol, uo
f-'r*o/.4",1
f
4,o*uJ
J
l^
-l*J-
- r*,'Jara
/'?,'^
7*tlt
'o/,
u^.
f.rf^ ,*:'y'oAa^
f
.utrr,,
=orr)',,)J
,- 4
rn--p,
ru.u/.To,
. ,/^
f/^,'ar'"-
e"rh. 2 ,*n-/^ z
/yr*.ul
-&"
r*t.yot^
p&4
,-,/^ 4,f-4
b^o-,fVt-o,7
3
1^ pJoL e
*/'?
a,ta'!<tna/,.
fo;l''
',:
fL"l'a'y'o/;a'
f\fono*J -y'"-r
d (
haSr*, a
3o.'
7
t"*-"
t4 2'
/'t*,'
/1'
,'nd'"r,Zr'
y'.'n pa.^ /utps.'t*t
1'2o'f "<
cuollrut,
1/.t^'2'^
LA L
vor
r,,
-r
-,
4'4v
,,
iuon
i'-Y!,n
vot
no
c.3 3
atro
(lt)
/rfin*J
' LrvL
PIPN 7TL:
-
/.5V
=4.
1V
-
0.33V
U'8
(
z.4V
er(t)
^'.-:''o/
f-Tct*' - l'*^ lrz'ua
a'alg1
4J
l',rur-
42.L,.-<-
,azt.'
I
trv>t*,^. 14
4-+V,
a r'*+utJ
7*'
,&
'r:*k,Qr;
,''-.r4a
p.dgr^'^
/'4
a( Jl*vt-'n e x *Lo
t(ul
m-y.a/,
t''u'&' Pe14
Qtl
tttvtl
y'LTd
Ouh,n',n*"
k ma,Y*"
d
'z''-"L
g
1nos ,ot/g*l/.
1^ tay'a,aa<l
5-
ARA
C/-7os
c
sV
v_..
=
3.s v
tnt
v
f hnt
V^ro,
vot
/1iP
Vcl
pa x
\,'
-V -V
-
YeL
=
,zt
-'oL
-
-mAx Vtax
nAx
vrHr,,,
=
z v
v"^o^
=
v
'cHr,u'
vot
-^^
4/u.
P<;',t.
77L
d, crln-o|
,
4LTC 1
Fr-&/r,r,,'
)ru..-'
-
i
gue
{;;T;V
ab 4.8 or-cLo /
.Jo-A
,*t+talt-e / ctt,"" o
n*
,
6,
jiv'
77L, Qu'n ,,^tlg*ou
"n
*ut-*'t
Vae
=
Yot
-Y, =
2'lv
-zl
:
o'4 v
F'A plt
/)
v v
-v =o'9Y-a'41
=4'4v
,rUL
=
2L .. CL
tY'l x
t4 la A
-,
o.4{
t'"ru uvt?: i1r.7t-L.L,1ta?./ ,/. do -l^
a,4V a/i,t-&t
/a1'
a*&r! o"t'^/"
8A.T
gaL/* a", Lt
A)petn't,
cnas
frEA?
E
S*LK"'; aI Pu$.an
,t)'z
D/67?s' Vtrl
=
0'7v a4'^ s"ab'u
J/-
+
5:-e-Y
4a
=
IC7YA
;L
/' C*Puulc
/a'u
w
x
Y
=
t
|
-j;y
r,
-n
nn^
71Lsc
/
&' l^
zu
* J'
"
,
zrtjnn,=zrA
i":, fr;i_j*r!
Talscr
fol,t",
-r1
lruJ Lyto/"=&'7t 1/'
cu"n',ta 4l
\t"
h7'
flo---
&/,,,h
c{
,{u c.-^rru,fL
(ve*.
r,,ou,f;n
il
I
;-l*" rr*
/"1t"
I
;;h
A /o,'.'*p.^fa-
- d';i'
( z+tsat)
'
: 7rat *
rrn
. Z
:
(1
xzc1t,a) +(zx la!*a)
=
z4olA
-7
-
r,
Yotl
-
O.zaV, a nr1't-rt*s
lru.fl
*hrQ.
rtt',t'/"
a-F
/n<Lgc^
u^
/a.ll
"/'
/w."xo*',E
.
(4
P*s"-
e4
Fo
PYJ
gao
o k
,nn/t"
aLTo
7
Baia
ft*
77L
.1, y'y,- /3
J
//
Yrs
=
Von
-1 i
/J
Yrt
=
{nt,'n*
=
4'-r/9' - 3
.5
v
=
0.9 V
/-r-v-
0,3)Y-- /- /7V
H.-
71lsa
,!.uey
)^):
P.>tlA:l/rrb
--__
O)visu|u
ja
o
l
ett
'-ln,"^
.
d L du.
hlee"rrb,
l: ca<./^ & Tn.s,."i e-, Pl
*
u ;f,.-.y' a- Z* Py :
R,
=
'z"sV
VHn.,
=
o-7v * Vrun,u
=
o.7v
* z{=
|"-Yv (VaJ,
*
ar'ry c,at /.73U. Z)
.
u &: l/<c
=
(z+o7a)
-
VoHnrr
--
5v
-
z-7t/
= =-
3Y
,Rt
2.3V
101A
=
983 .,2
V
z
Rt=
hax
Alvf J/OA
{A /U/a.a'ot
/114P1rca-
4{
(4.
/rt7,tttAf'4e.ta
.'mrr*;
/y.1*
,
.irr4*
*r,tt,Prr,,4 *t
. ,4
/ar-
{..ur,
L a..fr'-/"Jd
aJg-
u,rr- op,tu..
,u.ta.a-'l
&,
, h nn.rr'/ ar
-
y'+
&.nt.r
/
,4 o-rro.,,J
ar.,
.lt v{I
-,o-{rn4t-.**
.' /'r't..
P^
o,
/o
^cmt*t
a 4t at,
(enttecmas
ot t4'
E/taF
/nLrl, tr/:"J *r!-rz*
&.- -4t
2*r. tr-.J..-
ml,u-t
a 4 aU.rJ
-'.13r^-/n*
lgr"-
/-. .*, 1,,*../.--, r ,, 'v
'ilsr
- /or. .a, l,r,-./.-,*r r
tyh
y'r-,./t4'J
o
ul
. nft4
-
L'od.n /.ao/.ilor,^_
/r4
/aaor-
:
C-Vcr
eata{. Jr,rlo i clp/vtllX
ryi ARtzzet>'cl
pAR-
..llt*'""er"/jjirJ a/86)
/t
PQsqa 3 .
- th
d''s.,iin^ h*"' tne^h'
u*'
fz.4-b?4
t- c.'t -/o
fu*.'.;
t un
-------
Ct',t-c.th ga
J*y
)f
4"6.^--
t-r/
/,n,""
/-o
7a47:ry
laaa ap* & /-
^o
pn,*" /tl a,-*!E
. O ,r*J.^
o-
/n
fyz-a
fB'.
2/-
y'a
c.,.1",1a
/ctt
VlLsae
//4rub
. c/ d.^s;.J-n /l-r- nt'zlv< ,y' o.--]t*. dizso*'Z Lt i-"J>J." J.4A
l/4ilD E sz,la-tl 4g.
_r/ 7,-a-Zt^
e a)nf a.u^J
^/."
/-t /r/."
,o
I
nnut./aan ?/r. /^ Fr;rot* P3,
',r-{A".r-
lot7.'1
Ooo"*'6-
4"/t*,6
"i'a'n
oo,b cr.'*."
elt /^
'r/rr,,r...;
&,''t..u'X
7
/-
F
zhifi-.,t
o.
rnotza.
&
tzt,
nn J &;/.
+s!
Pno/a-ta 4
-
tlytn
/"n t',t'taz<' I
t t1
3:
oh,"h r
i O
u, &to t+*
e"*.J+s tu,,
y'o
I
o
fa(a).
/o
,'/ra
g<ao!
nt-t.r,-,*,- |
-
^*g"J.',*",t
J"r
"o,
*r'rJ, Rr, Pr,
| :
,n, Loa.^
fitt-;er^". *,, t'**, dl
s
l7u'othrr,
L
/^t'-o.t,ua,a,i
eqft)
|
r
t*o _45,:
vrn' d.-"s e
,l !,
V
v
R .
,|'uo-.,
d, V d,t'-
*ro,- tl I
v
-t-t-
v92f.4t t-, .! u.s a-4A rr+o t /;
I
rtcuca
p3
lrt rn t, rt+,np*" hs.Ew
t t t
i.,t/.?,/,?a-.
< R_,,*.
&*o f*o-S*
.*:4 l. r*,7ry'-".-.:.Ter^f-
dl 6'L
fana. z*,*
d. '^r^'J rn"onrar-s,..
P.un .J t- cl
.L"
4;r..,.rr.t
et-
& V
y'R
)
rL-,,u I^s ,J,rrl nSrrtu.&-r o R/, nz.
',*u7, *io
=
/48.i
;;,;,'i1H'-
^
'-'/r'in"o/""
^htavsn
4
,t I tt- > n
-
'
o ,-r#:;,';\ E*,
llo*"nnzctw
R
(q V
=
z'Z
i
p
=
/
go thTv""
'1
let
to
"'n'{"'r" R
(.)
v=3.o,
p=
/3o
frr.
-T*=-v
FI<UB P,{
-
P4o6/cuzS,-
Paq dn
u*r-& ,/"s
po,n, Rl yRz
dt PbT4,tr&fu.nnq i( f+,w*u
:
-/@n*^"t/"tr-;;;7";-
pa* lj-
A'/r-
o& t es'eAt'.s +,"'eo/.
pv.
al lq
'aSu"1*
{a*-
[3
l{'{7n;,74i,
z+-r
, Pa<. t*q^
e/x't.
4*P&,
h
e;tru,;,c..-r,
Za
i.Zaa ,l-/.
/a*.L'
,r- &l" tx.eL.u or.^ Vo
=VoLnt<
'j
Yg
=
VoHn,o
.@'ueonx
a
_
Aritmtlca
para
computadores
In precisin ruunrica
es el alma de la ciencia
Srn D'.rncy WexrwonrH THoivrpson-
On Gro*'th and Form, 1917
Los cinco componentes de un computador
"l"i"o"
Evaluacin del
rendimiento
Computador
Procesador
147
148 Organizacin y diseo de computadores
4.1. lntroduccin
Las palabras de los computadores estn compuestas de bits; as las palabras pueden
representarse como nmeros binarios. Aunque los nmeros naturales 0, 1,2, etc., pueden
representarse en forma decimal o en forma binaria.
qu
ocurre con los dems nmeros
que normalmente se presentan? Por ejemplo:
r
Cmo
se representan los nmeros negatir-os?
r
Cul
es el mayor nmero que se puede representar en una palabra de un computador?
r
Qu
ocurre si una operacin crea un nmero ma]-or que el que puede ser represen-
tado?
r
,Qu
ocurre con los nmeros reales
1'
fraccionarios'l
Y lo que sirve de brse a todas estas cuestiones es un misterio:
Cmo
el hardrvare suma.
resta. multiplica o divide los nmeros en realidad'l
El objetivo de este captulo es descubrir este misterio, incluyendo la representacin de
los nmeros, algoritmos aritmticos, hardl'are que siguen estos algoritmos, y las implica-
ciones de todo esto en los repertorios de instrucciones. Estas ideas pueden incluso explicar
peculiaridades qlle ya se haban encontrado en los computadores. (Los lectores que estn
familiarizados con los nrmeros binarios con sisno pueden saltar las dos siguientes seccio-
nes e ir a la Seccin 4.4 en la pgina 159.)
4.2. Nmeros negativos
menos infinito: Lo ns pequeo
Innrero
Ltu puede ser representado en un ttpo particular de
mriablel no necescn'iant'tente ni incluso habiiualnente la snple negacin tle ns it{inito.
Eruc R.rvuoso, The Netv Hacker's Dictionarv. l99I
Los nmeros pueden ser representados en c.ralquier base; las personas prefieren la base
diez y, como examinalnos en el Captulo 3. la base dos es mejor para los computadores.
Como deseamos, frecuentemente. tratar con nmeros decimales y binarios, para evitar
confusiones subindicamos los nmeros decimales con dez y los nmeros binarios con dos.
En cualquier base el valor del dgito i-simo d es
d
x
basei
donde i comienza en 0 y se incrementa de derecha a izquierda. Esto nos conduce a una
forma obvia para numerar los bits en la palabra: Utilizar sencillamente la potencia de la
base para ese bit. Por ejemplo,
1011do.
representa
(1
x 23) +
(0
x 22) +
(1
x21) +
(1
x 20)6i..
=(1
x8)+(0x4)+(1 x2)+(1 x't)diez
=8+0+2t1or",
=
lli"t
0000 0000 0000 0000 0000 0000 0000 1011
Aritmtica para computadores 149
Por tanto, los bits se numeran 0. 1,2,3, ... de derecha a izquierda en una palabra. El
esquema siguiente muestra la numeracin de los bits en una palabra iVfIPS y la ubicacin
del nmero 1011o.:
313029?827262524232??12019181716151413121110 9 8 7 6 5 4 3 2 1 0
(32
bits de ancho)
Como las palabras se consideran rerticalmente y tambin horizontalmente. ms a la
tlc'recha y ms a la izquierda puede no ser claro. Por consisuiente. ia frase bit ntetrcs
signiJicatto se utiliza para referenciar el bit de ms a la derecha (bit 0 anterior) y br rrrrs
sigrlicatiro para el bit de ms a l:r izquierda (bit 31).
La pirlabra iVIIPS es de 32 bits. as podemos representar l3r dilerentes patrones
de 32 bits. Es natural que estas combinaciones representen los nmeros desde 0 hasta
lr2
-
1
.291.967.1956..).
0000 0000 0000 0000 0000 0000 0000 0000do,
=
Odi..
m00 0000 0000 0000 0000 0000 0000 0001do,
=
1di".
0000 0000 0000 0000 0000 0000 0000 0010o,
=
2iu,
lttt
111 1
1111
111
111
111
111 1111
111 1111
111 1111
11 1111
11 1111
11 1111
111 111 1 1 101do,
=
4 .294 .967 .293di",
111 1111 11100o"
=
4 .294.967 .294di",
111 1111 1111o.
=
4.294.967.295di,,
Los programas de computadores calculan nmeros positivos y negativos. por ello
necesitamos una representacin que distin-ea los positivos de los negativos. Esta represen-
tacin debera establecerse lo ms uniformemente posible, ya que sera delicado poder
representar, por ejemplo,2000d,". pero no
-2000,ri...
Como una palabra de 32 bits tiene un
nrmero par de patrones de bits, una representacin equilibrada parece correcta. La razn
es que necesitamos representar el cero rns un nmero igual de nmeros positivos que de
nirmeros negativos. La alternativa para nmeros positivos y negativos desequilibrados es
tener dos patrones de bits que representen el 0. El remedio de patrones de dos bits
diferentes para representar el 0 es peor que el mal dei desequilibrio. as los computadores
cle 32 bits utilizan el siguiente convenio desequilibrado:
0000 0000 0000 0000 0000 0000 0000 0000do.
=
Odi".
0000 0000 0000 0000 0000 0000 0000 0001do,
=
1di".
0000 0000 0000 0000 0000 0000 0000 001Oao"
=
20i".
iir l ii1 i111 1i11 1i11 1111 1111 1101o.
=
2.147.483.645di",
0111 1111 1111 1111 1111 1111 1111 11 10o,
=
2.147.483.646di".
0111 1 111 1111 1111 1111 1111 1111 11 11o.
=
2.147.483.647d.",
1000 0000 0000 0000 0000 0000 0000 0000do,
= -2.147.483.48di".
1000 0000 0000 0000 0000 0000 0000 0001o.
= -2.147.483.647di",
1000 0000 0000 0000 0000 0000 0000 0010o,
= -2.147.483.6t+6di".
44
ll
a4
tl
11
1111 111
1111 111
1111 111
1111 1111 1111 1101
do, = -3di",
1111 1111 1111 1110o,
= -2r".
1111 1111 1111 1111o,
= -1i",
150 Organizacin y diseo de computadores
La mitad de los nmeros positivos, del 0 al 2.147.483.64'1o,., (2"
-
1), utilizan la
misma representacin que antes. El siguiente patrn de bits (1000 .... 0000,r",) representa el
nmero ms negativo
-2.141.483.648di",
(-2tt).Este es seguido por un conjunto decre-
ciente de nmeros negativos:
-2.147.483.647di,,
(1000...0001d",)
decreciendo hasta
-
16".
(1111 ... 1111d",). Por tanto, hay
justamente
un nmero negativo,
-2.141.483.6480..,
que
no tiene correspondencia con ningn nmero positivo. Este convenio para representar
nirmeros binarios con si-9no se denomina representacin en contplemento a dos. Esto
asegura que .\ + (-.r)
:
0.
Adems con un solo 0, la representacin en complemento a dos tiene la ventaja de que
todos los nmeros negativos tienen un I en el bit ms signihcativo. Consiguientemente, el
hardrvare necesita examinar slo este bit para ver si un nmero es positivo o negativo
(considerando el 0 positivo). Este bit particular con frecuencia se denomina bit de sigrio.
Para reconocer el papel del bit de signo. podemos representar los nmeros positiros y
negativos en funcin del valor del bit multiplicado por una potencia de 2 (aqu xi signifrca
el bit i-simo de ,r):
(.r31 x-231 +1-x30*230) +(-r29x2:e) +...+(-r1 x21; +(.x0x20)
El bit de signo es multiplicado por
-211 1'el
resto de los bits se multiplican despus por
l'ersiones positivas de sus respectivos valores de base.
EJEMPLO
Cul
es el valor decimal de este nmero de 3l bits en complemento a dos'J
1111 1111 1111 1111 1111 1111 1111 1100d".
RESPUESTA
Sustituir los valores de los bits en la frmula antenor
(1 x
-l'')
+
1l
x
230. + (1 x
l:ot
-
rlxl:) +(0x21; +10x20
-l3r+13o12e+...+21
-
l.l+7.-183.648di", + 2.147.483.644di",
_1
De forma distinta a los nirmeros explicados anteriormente, las direcciones de memo-
ria comienzan naturalmente en 0 y continan en el sentido de las direcciones
crecientes. Dicho con otrls palabras, las direcciones negativas no tienen sentido. Por
trnto. los programas tratan a veces con nirmeros que pueden ser positiros
)'neg"iti-
vos \''r veces con nmeros que pueden ser slo positiros. Los lenguajes de progra-
macin reflejan esta distincin. C. por ejemplo. denomina a los primeros /rr'().t
(declarados como int en el programa)
I
ir los ltimos como ,rrr'os sin sit/lrt
tunsi
gned i nt t.
Aritmtica para computadores 151
Las instrucciones de comparacin deben tratrr esta dicotoma. A veces un
patrn de bits con un I en el bit ms signicativo representa un nmero negativo y,
por supuesto, es menor que cualquier nmero positivo, que debe tener un 0 en el bit
ms significativo. Con los enteros sin signo, por otro lado. un 1 en el bit ms
significativo representa un nmero que es tnayor que cualquiera que comience con 0.
MIPS ofrece dos versiones de la comparacin inicializat'-sobre-tnenor-que (set-ort-
less-than) para manejar estas alternativas.lnicializar sobre ntenot'cue (sLt)e irriciali-
zar sobre n'tenor clue inrttetliaro
(sLti)funcionan con enteros con signo. Los enteros
sin si-gno se comparan utilizando ncictli:ar sobre menot' que sitt sitno (set on less tlnn
ttrtsigned)
(sLtu)
e iticittli:ar sobre ntenot' que inntediato sin sicltto
(set
on less tlrcut
inunetliate tnsitlnetl
)
(s L t i u ).
EJEMPLO
Suponer
que el registro S16 tiene el nmero btnano
1111 1111 1111 1111 1111 1111 1111 1100d",
y qLre el registro Sl7 tiene el nmero binario
0000 0000 0000 0000 0000 0000 0000 0001d",
Cules
son los valores de los reeistros 58 y 59 despus de estas dos instrucciones?
sLt $8, 516, 517 # comparacin con signo
sLtu $9, $16, 517 # comparacin sin signo
RESPUESTA
El valo del registro S16 representa
-
I si es un entero y 4.294.967.295.. si es un entero sin signo. El
valor del registro Sl7 representa I en cualquier caso. Por tanto. el registro S8 tiene el valor I. ya que
-
1i",
(
11..,
t
l registro 59 tiene el valor 0, ya que 4.294.967.295di.. ) l,ri...
Antes de ir a la suma
]'
resta. eraminemos algunas abreviaciones cuando se trabala con
n[rmeros en complement a dcrs. La primera abieviacin es una forma rpida de negar un
nirmero binario. Sencillamente cambiar cada 0 por 1 y cada 1 por 0. despus de sumar I al
resultado. Esta abreviacin est basad en la observacin de que el nmero representado
al invertir cada bit est desplazado en I del complemento ne-gativo a dos del nmero.
EJEMPLO
Negar 2.. y despus comprobar el resultados negando
-
2",
RESPUESTA
2..
-ot ez
0000 0000 0000 0000 0000 0000 0000 0010d".
l: Nesamos este nmero invirtiendcr los bits y sumando
152 Organizacin y diseo de computadores
1111 1111 1111 1111 1111 1111 1111 1101d."
r
1ao,
=
,111 1111 1111 1111 1111 1111 11,11 1110d",
20,r.
En la otra direccin,
1111 1111 1111 1111 1111 1111 1111 1110d.,
se invierte primero y despus se incrementa:
0000 0000 0000 0000 0000 0000 0000 0001d.,
4
rdos
0000 0000 0000 0000 0000 0000 0000 0010d",
?o,,
La segunda abreviacin nos dice cmo convertir un nmero binario representado por
r bits en un nlmero representado por ms de r bits. Por ejemplo, el campo inmediato en
las instrucciones de car-ga, almacenamiento. salto. suma e inicializar sobre menor que
contiene un nmero de 16 bits en comDlemento a dos.
que
Duede variar desde
-32.768di,,(-2t5)
hasta 32.7670,,,(2"
-
t;. eara sumar el campo inmediato a un registro
de 32 bits, la mqr"rina debe convertir ese nmero de 16 bits en su equivalente de 32 bits.
La abreviacin es tomar el bit ms signilicativo de la cantidad menor, el bit de signo, y
replicarlo para rellenar los nuevos bits de la cantidad mayor. Los bits antiguos se copian
sencillamente en la parte derecha de la nueva palabra. Esta abreviacin comrnmente se
denomina extensin cle siqno.
EJEMPLO
Convertir versiones binarias de 16 bits de 2".
)'de -2..
eo nrmeros binarios de 32 bits.
RESPUESTA
La versin binaria de 16 bits del nmero 2 es
0000 0000 0000 0010o.:20i..
Se convierte a un nmero de 32 bits haciendo l6 copias del valor del bit ms"'signihcativo (0)
1
.colocndolo en la mitad izquierda de la palabra. La mitrd derecha conserva el valor antigr,ro:
0000 0000 0000 0000 0000 0000 0000 001Odo":Zdi..
Si negamos la versin de 16 bits de 2 utilizando la abreriacin anterior. entonces
0000 0000 0000 0010d""
se convierte en
*
,111 1111 111'',01:::
1111 1111 1111 1110d.,
Crear una
colocarlo
a la
111 1
Este truco funciona porque los nirmeros positivos en complemento a dos pueden
considerarse
qlle tienen un nirmero infinito de ceros (0)
a la izquierda v los nirmeros
riegativos tienen un nmero inllnito de unos (l). Colocar un nirmero en complemento a
dos en una palabra irnicanlente separa esos bits para hacer que el nmero coja en la
palabra,
y la ertensin del signo los restaura.
El punto principal de estr seccin es qLre necesitamos reprcsentar los enteros positiros
r neg:rtivos en una pirlabra de un computador y, aunque ha1 pros
i'
contrrs parr
cualquier opcin. la eleccin abrumadora durante los rltimos l5 aos ha sido el contple-
ntento r dos. La FigLrra 4.1 muestrr lo aadido al lenguaje ensamblador \llPS en esta
scccin.
(El len_euaie mquinrr \llPS se ilustra en la pgina xrriii de este libro.)
Lenguaie
Fig ura 4.'l . Arqu itectu ra M IPS revelada hasta ahora. La negrita indica partes de esta seccin aadidas a
la arqutectura MIPS reveladas en el Captulo 3 (la Figura 3.16 de la pgina 115). El lenguaje mquina MIPS
se ilustra en la pgina xxxiii de este libro.
Aritmtica para computadores 153
versin de ,j2 bits del nmero ne-sativo si-enifica copiar el bi de signo diecisis veces y
izquierda:
1111 1111 1111 1111 1111 1111 111Odo,:-2".
Operandos MIPS
Nombre Ejemplo Comentarios
32 registros JU, J r, ), ..., )J I Posiciones roidas oara datos. En I\4lPS los datos deben estar en
regstros para realizar la aritmtica. El registro S0 de MIPS siempre es
igual a 0. El registro S1 se reserva para que el ensamblador maneje las
pseudornstruccrones y grandes constantes.
.10
^^l^L-^^
lJdtdut
oJ
de memoria
Memoria{01,
Memoria[4], ...,
Memoria[429.1967292
Accedidas slo por instrucciones de transferencia de datos. MIPS utiliza
slo direcciones de bytes, as las palabras secuenciales difieren en 4. La
memoria contiene estructuras de datos, tales como arrays, y registros
derramados, como los salvados en las llamadas a los procedimientos
ie ensamblador
Categora lnstruccin
I
Ejemplo Significado Comentarios
Aritmtica
sumar . add S'1,S2,S3 > |
=)Z+)J
3 operandos; datos en reg
restar sub S1,S2,S3 3 operandos; datos en reg
sumar inmediato 'addi S1,S2,100 S'l =52+100 Usado para sumar constantes
Transfe-
rencta
de datos
cargar palabra , lw S1,100(52) S'1 =Memoria[$2+
100] Dato de memoria a registro
almacenar palabra ,sw
S1,100(52) MemoriaI52+ 100]=S1 Dato de registro a memoria
cargar superior : lui 51,100
inmediato
216 100 Carga.constantes en 16 bits
superrores
Salto
co nd icional
saltar soore igual beq 51,S2,100 si
(S1==S2) ir a PC+4+100 Test igual; salto relativo al PC
saltar sobre no iguai bne S1,S2,100 si
(S1!=S2) ir a PC+4+100 I Test no igual; relativo al PC
inicializa sobre sf t S1,S2,S3
menor que
si
(S2 < S3)S1 = 1
Sl nO>l:U
Compara menor que;
comp. a 2
inicializa menor qus slti S1,S2,100
nm.
si
(S2--:100)51 :1;
Compara constante menor que;
si no S1 =0 I comp. a z
inicializa sobre sltu S1,S2,S3
menor que sin signo
si {S2<53} $1:1
si no 51 =0
Compara menor que;
nmeros sin signo
inicializa menor que sltiu S1,52,100
Inm. stn srgno
si
(S2< 100)51
--
1;
si no 51 =0
Compara menor que constante;
numeros srn srgno
B if u rcacin
i nco nd icional
bifurcar
j 10000 ir a 10000 I Bifurca a direccin destino
bif. registro jr S31 ir a S31 Para cambiar, vuelta de
rProcedmiento
bif. y enlazar
.jal
10000 S31
:
PC + 4; ir a 10000 Para llamada a procedmiento
154 Organizacin y diseo de computadores
Elaboracin: El complemento a dos recibe su nombre de la regla:
.la
suma de un nmero de
n bits y su negativo es 2',', por consiguiente el complemento o negacin de un nmero x en
complemento a dos es 2n
-
x. Una representacin alternativa obvia al complemento a dos utiliza
el bit de ms a la izquierda como el signo, y los 31 bits restantes representan el nmero. Esta
representacin en magnitud y signo tiene el inconveniente de tener 0 positivo y 0 negativo.
Adems es ms difcil disear un sumador para signo y magnitud, como veremos en breve. Una
tercera alternativa se denomina complemento a uno. El negativo de un complemento a uno se
encuentra invirtiendo cada bit, de 0 a 1 y de 1 a 0. Esta representacin es similar al complemen-
to a dos excepto que tiene dos 0: 00...00do. es el 0 positvo y 11 ...
'l1oo.
es el 0 negativo. El
nmero ms negativo 10... 000do" representa
-2.147.483.647di..
y as los nmeros positivos y
negativos estn equilibrados. Una notacin final, que examinaremos cuando expliquemos el
punto flotante, es hacer que el valor ms negativo sea 00 ... 000do. y el valor ms positivo sea
11 ... 110o., teniendo el 0 normalmente el valor 10...00dos. Esta representacin se denomina
notacin desplazada (biased|, para ello se desplaza el nmero de manera que el nmero ms el
desplazamiento sea no negativo.
Como punto final, con el fin de ahorrar espacio, muchos programas visualizan nmeros
utilizando una base mayor que la binaria que se convierte fcilmente a binario. Como casi todos
los tamaos de datos del computador son mltiplos de 4, los nmeros hexadecimales (base 16)
son populares. Los 16 dgitos hexadecimales son 0,1,2,3, 4, 5, 6, 7, 8, 9, a, b, c, d, e y f. C
utiliza la notacin lxnnnn para representar un nmero hexadecimal. En este libro utilizaremos o
el subindice hex o la notacin de C.
4.3. Suma y resta
Resta: Anga truculenta le la suma
Ntinrcro 10, Los die: mejores cursos p(ra atletds de unafactor'a de
ftbol.
D.rvro LrreRn.qN* ET.\1.. Libro de listas de |os diez mejores. 1990
La suma es exactamente 1o que se podra esperar en los computadores. Los dgitos se
suman bit a bit de derecha a izquierda, transmitiendo los arrastres al siguiente dgito de la
izquierda, hasta que se acaban. La resta utiliza la suma: El operando apropiado se niega
sencillamente antes de ser sumado.
EJEMPLO
Tratar de sumar 6", coo 7i.. y'despus restar 6., de 7,"..
RESPUESTA
0000 0000 0000 0000 0000 0000 0000 01'11o,
=
7i".
+ 0000 0000 0000 0000 0000 0000 0000 01 10do,
=
di".
=
0000 0000 0000 0000 0000 0000 0000 1 101do"
=
13i".
Los -1 bits de la derecha tienen toda la accin: la Fieura -1.2 muestra las sumas y arrastres. Los
arrastres se muestran entre
parntesis.
las flechas indican cmo se transmiten.
+
;\ota dl trutluctLtr: David Letterman es un presentador de un programa de humor de la TV nL)rteame-
ricana dondc se Dresentan listas de las diez meiores maner:rs de hacer cosas.
Aritmtca para computadores 155
(0,
0
n
(r)
1
I
(0)
1
I
(0)
0
0
tlt
0
0
lArrastrel
1
0
Figura 4.2. Suma binaria, que muestra los arrastres de derecha a izquierda. El bit de ms a la derecha
sLima I a 0, produciendo un bit de suma de 1 y un bit de arrastre de 0. Por consiguiente, la operacin para el
segundo dgito a la derecha es 0
-
1 + 1. Esto genera un 0 para este bit de suma y un arrastre de 1. El
teer dgitdes la suma de 1 - 1
-
1. produciendo un arrastre de 1 y un bit de suma de 1. El cuarto bit es
1 + 0 + 0, dando una suma de 1 y ningn arrastre'
Restar 6", de 7". pude hacerse directamente:
0000 0000 0000 0000 0000 0000 0000 0111o"
=
71".
- 0000 0000 0000 0000 0000 0000 0000 01 10d".
=
di..
=
0000 0000 0000 0000 0000 0000 0000 0001do.
=
1di..
o via suma, utilizando la representacin en complemento a dos de
-
6:
0000 0000 0000 0000 0000 0000 0000 01116o"
=
76i..
+ 1 111 1111 1111 1111 1111 1111 1111 1010o, = -i".
=
0000 0000 0000 0000 0000 0000 0000 0001do, =
'ldi".
La nica complejidad de la suma en el computador es la posibilidad de que la suma
sea demasiado grnde para que se represente adecuadamente. Sin que importe la forma de
representacin de los nmeros, es posible que la suma de dos nmeros de 32 bits sea
demasiado grande para represenrarla
por 32 bits. Este evento se denomina desbordamien-
to o rebose (ouerflorv).
Por ejemplo, ia suma Ce estos dos nmeros con signo es muy grande para 32 bits:
0111 1111 1111 1111 1111 1111 1111 1111o"
=
2'147
'483'647di"'
+ 0000 0000 0000 0000 0000 0000 0000 0010o"
=
20r.,
=
f000 0000 0000 0000 0000 0000 0000 0001do. = -2.147.483.647di".
La suma de 2.147.483.6-17,ji..
+ 2 debe sef 2.141.48'3.64gdi,,, pero en su lugar obtene-
mos el valor negatit:o
-2.117.483.647di,..
El problema es que necesitamos 33 bits para
representar 2.147.483.649i.. lt la notacin en complemento a dos, pero el tamao de
palabra es slo de 32 bits- dems. el resultado tiene solamente los 32 bits inferiores de la
suma real.
El desbordamiento se puede presentar en la resta. Por ejemplo. para restar 2 de
-2.147.483.641di"..
convertimos 2 a
-2
y lo sumamos a
-2.147.483.6470i".:
'1000
0000 0000 0000 0000 0000 0000 0001ao' = -2
'147 '483'647"'
+ 1111 1111 1111 1111 1111 1111 1111 1110o,
=
?otu.
0111 1111 1111 1111 1111 1111 1111 1111o,
=
2.147 -483-647di",
156 Organizacin y diseo de computadores
Operacin Operando A Operando B Resultado
A+B 0 0 <0
A+B <0 <0
0
A-8
n
<0 <0
A-B <0 n
U
Figura 4.3. Condiciones de desbordamiento para suma y resta.
De nttevo otra vez, el resultado de
-2.147.-18-r.6-17d,", -2
ser
-
2.141.483.6490,"., pero no
podemos representar ese resultado en 32 bits. por lo que obtenemos el r'rlor
lro.sitir.rr
errneo de ?.147.483 .647
di",.
,Cundo
se presenta el desbordamiento? Cuando se slrman operandos con diferentes
si-9nos. no puede presentarse desbordamiento (ot'ejlol').
La razn es qlle la suma no debe
ser ma)'or que uno de los operandos. Por ejemplo.
-
l0 + 4
:
-
6. Como los operandos
cogen en 32 bits y la sum:r no es mavor qlre Lln operzrndo, lr suma debe co_ser tambin en
-i2
bits. Por tanto, el desbordamiento no se puede presentar cuando se suman operandos
positir,os y negativos.
Ha1' restricciones similares a las ocurrencias de desbordrmiento durante la resta. pero
ste es el principio contrario: Cuando los si-snos de los operandos son irTrrrzles, no se pue<1e
presentar desbordamiento. Para ver esto. recordar que _\
- )'
:
_\ + (
-,r.),
por.que
restamos al negar el segundo operando y despus sllmamos. As, cuando restamos operan-
dos del mismo signo terminamos sumanclo operandos de diJbrentes signos. Del prrafo
anterior sabemos que el desbordamiento no puede presentarse en este caso.
Aunque hemos examinado cundo no puede ocurrir desbordamiento. todavia no
hemos respondido a cmo detectarlo cuando ocLlrre. Como vimos en los ejemplos anterio-
res, stlmar o restar dos nmeros de 32 bits puede dar un resultado que necesite 33 bits
para expresarlo completamente. La falta del bit trigsimo tercero signica que cuando se
presenta desbordamiento. el bit de signo toma el t'alor del resultado en lu_qar del signo
propio del resLrltado: Como necesitamos exactamente un bit extra. solamente el bit de
si-eno puede ser errneo. Es decir. ei desbordamiento se presenta cuando se suman dos
nmeros positivos y la suma es ne-eativa. o ricel'ersa. Un desbordamiento se presenta en
tlna resta cuando restamos un ntmero negativo de un nmero positivo y obtenentos un
resultado negativo, o cuando restamos un nmero positivo de un nm.ero negativo
,\
obtenemos un resultado positivo. La Figura J.3 muestra la cornbinacin de operlclones.
operandos, y resultados que indican desbordamiento. (El
Ejercicio 4.29 da una observa-
cin para detectar el desbordamiento de manera ms sencilla en hardrvare.)
El diseador de la mquina debe decidir cmo tratar los desbordamientos arirmtr-
cos. Aunque lenguajes como C dejan la decisin al diseador de la mqtiina. len,sua-
jes
como Ada, Fortran y'Lisp requieren qLle se notillque al programa. N,llPS detecta
Aritmtica para computadores 157
el desbordamiento con una excepcin, tambin llamada enupcirt en muchos
computadores. Una excepcin o interrupcin es esencialmente una llamada no plani-
cada a un procedimiento. La direccin de la instruccin que produce el desborda-
miento se guarda en un registro.
1'el
computador bifurcr a una direccin predefinida
para invocar la rutina adecuada para esa excepcin. La direccin interrumpida se
guarda para que en al-eunas situaciones el pro-erama pueda continuar despus que se
ejecute el cdi_eo correctivo
(r'ase
Captulo 7). MIPS incluye un resistro denomina-
do contador de excepciotrcs del progrann (exceptiort progrotn cotntter - EPC) que
contiene la direccin de la instruccin que provoc la excepcin. La instruccin
tranferir destle el control tlel sistettr.:- (rnouefront s_l,slerl control) (mf c0) se utiliza para
copiar EPC en un resistro para que el software de MIPS tenga la opcin de volver a
la instruccin culpable ra unr instrLrccin
"Bifurcrr
registro" (Jump register). El
Capitulo 5. Seccin
-5.6.
cubre las excepciones con ms detalle: los Captulos
7
i
3
tambin describen situaciones donde se Dresentan excepciones e interruociones.
Hemos visto cmo detectar desbordamientos para nrmeros en complemento a dos en
una mquina.
Qu
ocurre con los enteros sin si-sno? Evidentemente, hay enteros sin signo
qlle son demasiado grandes para ser representados con 32 bits. pero normalmente no se
consideran situaciones de desbordamiento. La razn es que los enteros sin signo se
utilizan normalmente para direcciones de memoria y, de lorma distinta a los nmeros
naturales, tienett un lmite linito
1'a
que las memorias son finitas. En nuestra mquina
N,liPS, la mxima memoria que un usuario puede direccionar directamente es
1.294.961.296i.. o 232 bytes.
El diseador de la mquina debe adems proporcionar un mtodo para ignorar el
desbordamiento en alsunos casos
)'
de reconocerlo en otros. La solucin lvllPs es la de
tener dos tipos de instrucciones aritmticas para reconocer las dos posibilidades:
r sumar
(add),
suman inmediato
(addi
) y restar
(sub)
producen ercepcio-
nes sobre el desbordamiento.
-'-
r sumar sin s'igno
(addu)/
sumar inmediato sjn signo
(addju).,.restar
sin signo
(subu)
rro producen excepciones sobre el desbordamiento.
Como C ignora los desbordamientos. los compiladres C de illlPS siempre generarn
versiones sin signo de las instrucciones aritmticas addu, addiu
1'subu.
Sin embargo.
los compiladores Ada de IIIPS escogen las instrucciones aritmticrs adecuadas. depen-
diendo del tipo de operandos.
El punto principal de esta seccin es que. independientemente de la representrcin. el
tlmao finito de palabra de los computadores signilicir qr.re liis operaciones aritmtices
pueden crcar resultados que s.rn mrrv grandes p'rra que cojan en un:r palabra de tam;lo
jo. Es fcil detectar desbordrmiento en los nrmeros natlrrales, aunque stos casi siempre
se ignoran porqlle los progrrmrs no quieren detectar desbordamiento para la aritnltica
de direcciones. el uso ms comn de los nirmeros naturales. El complemento a dos
presenta Lrnl gran dificultrd.
-\a
que algr-rnos sistemas soltrvrre requieren la deteccin del
desbordamiento. rs que hor da todas las mquinas tienen una forma de detectarlo. La
Figura -1.4 muestra lo que se ha aadido a la arquitectura NIIPS en estI seccicn.
158 Organizacin y diseo de computadores
Figura 4.4. Arquitectura MIPS revelada hasta ahora. La negrita indica las partes reveladas de la Figu-
ra 4. 1 en la pgina 153). El lenguaje mquina MIPS se ilustra en la pgina xxxiii de este libro.
Elaboracin: En el texto precedente decimos que se copia EPC en un registro va mfc0 y
despus se vuelve al cdigo de interrupcin va Bifurcar registro (Jump register). Esto conduce a
una pregunta interesante:
Cmo
se puede utilizar Bifurcar registro (Jump register) para volver
al cdigo interrumpido e incluso restaurar los valores originales de todos los registros? O bien se
restauran primero los registros antiguos, destruyendo as la direccin de vuelta del EPC, o se
restauran todos los registros excepto el que tiene la direccin de vuelta para que se pueda
bifurcar
-significando
que una excepcin cambiara un registro en cualquler instante de la
ejecucin del programa!-. Ninguna opcin es satisfactoria. Para liberar al hardware de este
Operandos MIPS
Nombre Elemplo Comentarios
32 registros u, s t, tz, ..., J I Posiciones rpidas para datos. En MIPS los datos deben estar en
registros p,ara realizar la aritmtica. El registro $0 de MIPS siempre es
igual a 0. El registro S1 se reserva para que el ensamblador maneje las
pseuoornslruccrones y grandes constantes.
230 palabras
de memoria
Memoria[0],
Memoria[4], ...,
Memoria[4294961292]
Accedidas slo por instrucciones de transferencia de datos. MIPS utiliza
slo direcciones de bytes, as las palabras
secuenciales difieren en 4. La
memoria contiene estructuras de datos, tales como arrays, y registros
derramados, como los salvados en las llamadas a los orocedimientos
Lenguaje ensamblador MIPS
Categora lnstruccn Eiemplo Significado Comentarios
Aritmtica
sumar add S1,S2,S3 >r:)z-J 3 operandos; excepcin posibk
resta r sub S1.S2.S3 )r=)z-5J 3 operandos; excepcin posibk
sumar inmediato addi S 1,S2,1 00 s1
:
s2. 100 + constante; excepcin posibk
sumar srn srgno addu S1,S2,S3 51:52-53 3 operandos; no excepciones
restar sn signo subu S1.S2,S3 51=52-53 3 operandos; no excepciones
sumar inmediato
sin signo
addiu S1,S2,100 51=52-100 + constante; no excepciones
transferir desde
reg. coprocesador
mfc0 Sl,Sepc 51
:
Sepc Usado para conseguir
excepcin PC
Transfe-
re ncia
de datos
cargar palabra lw S1.100(52) S'l = illemoria[S2+'100] Dato de memoria a reoistro
almacenar palabra sw S1,100(52) MemoriaI52+ 100]=S1 Dato de registro a memoria
cargar supeor
inmediato
lui 5l 100 51 =100
x 2ro Carga ctes. en 16 bts
superores
Salto
cond iciona I
saltar sobre igual beq S1,52,100 si
(Sl
==S2) ir a PC+4+ 100 Test igual; salto relativo al PC
saltar sobre no igual bne S1,S2,100 s
(S1l=S2)
r a PC+4+100 Test no igual; relativo al PC
inicializa sobre
menor que
slt S'1,S2,S3 si
(S2<S3)Sl=1
stno5=u
Compara menor que;
comp. a 2
inicializa menor
que inmediato
slti S1,S2,100 si
(S2 < 100)S1 = 1
si no 51:0
Compara constante menor que;
comp. a 2
tntcta||za menor
que sin signo
sltu S1,S2,S3 si {S2<S3) 51 =1
si no 51 =0
Compara menor que;
no natural
inicializa menor que
inmediato sin signo
sltiu S1,S2,100 s
(S2<
1001S1
:1
si no S1 =0
Compara < constante; natural
B ifu rcaci n
incorrdicional
bifurca r
i
10000 ir a 10000 Bifurca a direccin destino
bif. registro lr5Jl rr a S3l Para cambiar, vuelta de
procedmig'nto
bif. y enlazar
lal
10000 S31 =PC-4; ir a 10000 Para llamada a orocedimiento
Artmtica para computadores 159
dilema,
los programadores MIPS acordaron reservar los registros $20
y
927 al sistema operati-
vo; estos registros no son restaurados en las excepciones. lgual que los compiladores MIPS
evitan
utilizar el registro
$'l
para que el ensamblador pueda utilizarlo como un registro temporal
(vase la Interfaz Hardware Software en la pgina 1
'13
del Captulo 3), los compiladores tambin
se abstienen de utilizar los registros $26
y
$27
para hacerlos disponibles al sistema operativo.
Las rutinas de excepcin colocan la direccin de vuelta en uno de estos registros y despus
utilizan Bifurcar registro (Jump register) para restaurar la direccin.
4.4. Operaciones lgicas
Ln locn'a es con
Ji'ecuencia
la lgic'a de una nrcte precistt ercesit'amente aclLhiada.
Ortve.R Weror.ll HolltEs, El outuatct de la nrcsa del /esaluro. 1858
Aunque los primeros computadores se centraban sobre palabras completas, pronto estuvo
claro que era til operar sobre campos de bits en una palabra o incluso sobre bits
individuales. Examinar los caracteres de una palabra, cada uno de los cuales se almacena
como 8 bits. es un ejemplo de tai operacin. Sigue que las instrucciones se aadieron para
simplicar, entre otras cosas. el empaquetamiento y desempaquetamiento de bits en las
palabras.
Un tipo de estas operaciones se denominaron desplctzamientos (sftry's). Estos desplazan
todos los bits de una palabra a la izquierda o a la derecha, rellenando los bits vaciados
con 0 (ceros). Por ejemplo, si ei registro $16 contiene
m00 0000 0000 0000 0000 0000 0000 0000
'1101d..
y se ejecutase la instruccin desplaza a la izquierda 8, el nuevo valor sera:
m00 0000 0000 0000 0000 0000 1101 0000 0000d."
Para complementar un desplazamiento a la izquierda, hay un desplazamiento a la
derecha. Las dos instrucciones de desplazamiento MIPS se denominan despla:cuniento
Igico a Ia izquiercla (shift IeJi logicat) (s L L
)
y desplazamtento lgico a la rlerecha (shft rigl
logica[) (srL). Para realizar la operacin anterior, suponiendo que el resultado vaya al
registro S10:
sLL S'10, $1,8
#
reg $10: reg $1 << 8 b'its
En el Captulo 3 retrasamos la explicacin del campo shatnt en el formato R. Significa
shift anrottnt (cantidad tle tlespla:anento) y se utiliza en instrucciones de desplazamiento.
Por consiguiente, la versin en lenguaje mquina de la instruccin anterior es
rs rt rd shamt funct
La codificacin de sLL es 0 en los campos op y'funct. rd contiene S10, rt contiene S16. v
shamt contiene 8. El campo rs no se utiliza v por tanto se pone a 0.
Otra operacin til que asla campos es A,VD. (Ponemos en maysculas la palabra
para evitar confusin entre la operacin y la conjuncin inglesa.) AND es una operacin
n
16 10 0 8 0
160 Organizacin y diseo de computadores
bit a bit que produce el resultado I slo si ambos bits de los operadores son l. Por
ejemplo, si el registro $10 todava contiene
m00 0000 0000 0000 0000 1101 0000 0000d".
y el registro $9 contiene
0000 0000 0000 0000 0011 1100 0000 0000d".
entonces, despus de ejecutar la instruccin ltlPS
and $8,$9/$10
#
reg $8
:
reg 59 & reg $10
el valor del re_eistro 58 sera
m00 0000 0000 0000 0000 1 100 0000 0000d",
Como se puede observar, AND se puede utilizar para aplicar una mscara a un
conjunto de bits que fuerzan 0 (ceros) donde hava un 0 en la mscara. Para coiocar un
valor en uno de estos mares de 0 (ceros), existe el complemento de AND denominado OR.
Esta es una operacin bit a bit que produce un resultado i si algn bit de los operandos
es 1. Para concretar si los registros 59
1'S10
no se han combinado desde el ejemplo
anterior. el resultado de la instruccin i"'IIPS
or $8,$9,$10
#
reg $8: reg $9 | reg $10
es este valor del registro $8
m00 0000 0000 0000 0011 1101 0000 0000d..
La Figura 4.5 muestra las operaciones lgicas de C y las correspondientes instruc-
ciones MIPS. Las constantes son tiles en las operaciones lgicas asi como en las
operaciones aritmticas, ya que MIPS tambin proporciona las instrucciones antl in-
mediato (and'i) y or inntedato (ori). Esta seccin describe las operaciones lgicas AND.
OR, y de desplazamiento que se encuentran en cada computador actual. La Fi_eura 4.6
resume las instrucciones MIPS para esas operaciones.
Elaboracin: Como and'i y ori normalmente funcionan con enteros sin signo, los inmediatos
tambin se tratan como enteros sin signo, significando que se expanden a 32 bits aadiendo 0
(ceros) a la izquierda en lugar de la extensin del signo. El ensamblador MIPS crea constantes
de 32 bits con el par de instrucciones Lui y oli;vase Captulo 3, pginas 109-110 para un
ejemplo de creacin de constantes de 32 bits utilizando Lui y addi.
Operaciones lgicas Operadores G lnstrucciones MIPS
Desplazamiento a la izquierda stL
Desolazamiento a la derecha srI
AND & and, and i
OR orl
Figura 4.5. Operaciones lgicas y sus correspondientes operaciones en C y MIPS.
Aritmtica para computadores 161
Figura 4.6. Arquitectura MIPS revelada hasta ahora. La negrita indica las partes desde la Figura 4.4 de
Ia pgina 158). El lenguaje mquina MIPS se ilustra en las contraportadas de este libro.
Ooerandos MIPS
Nombre Ejemplo Comentaios
32 registros )u, ) r, )1, ..., 5J I Posiciones rpidas para datos. En MIPS los datos deben estar en reoistros oara
realzar la aritmtica. El registro S0 de MIPS siempre es igual a 0. EI re-gistro St se
reserua para que el ensamblador maneje Ias pseudoinstrucciones y grandes cons-
ta nIes.
.10
^^r-L--^
de memoria
Memoia[0],
Memoria[4],...,
M e mo ria [4291-o67292.
Accedidas slo por nstrucciones de transferenca de datos. fvllpS utiiiza slo
direcciones de bytes, as las palabras secuenciales difieren en 4. La memoria
contiene estructuras de datos, tales como arrays, y registros oerramaoos, como
los salvados en las llamadas a los procedimientos
Lenguaie ensamblador MIPS
Categora Instruccin Eiemplo Significado Comenlarios
Aritmtica
SUMAT add S1,S2,S3 s1=s2+s3 3 operandos; excepcin posible
resta I SUO 5 I,5I,)J 3 operandos; excepcin posible
su-ar inmed;ato
Iaddi
S't,S2,100 constante; excepcin posible
sumar srn sgno addu S'1,S2,S3 3 operandos; no excepciones
restar srn srgno subu S1,S2,S3 3 operandos; no excepciones
sumar inmedato sin signo addiu S1,S2,100 s1=s2-r00 conslante; no excepcrones
transferir desde reg
coprocesaoor
mfco Sl,Sepc Usado para conseguir
excepcin PC
Lgicas
ano and S l,S2,S3 sl:s2 & $3 3 reg. operandos; AND Logica
or or 51,S2,S3 $1 =S2rS3 3 reg. operandos; OR Logica
and nmediato and S1,S2,100 Sl =S2&100 reg. Logca AND. constante
or nmediato or S1,S2,S100 51 = 52 100 reg. Logica OR, constante
desplazamento lgico a
la derecha
sll 51.S2.S10 51=52<<10 Desplaza izquierda pot constante
desplazamiento lgco a
la izouierda
srl 51,S2,S'10 51=52>>10 Desplaza derecha por constante
Transfe-
rencia
oe oalos
cargar paraora w 51,100(52) S1 = MemoriaI52+100] Dato de memoria a registro
almacenar palabra sw 51.100(52) MemoriaI52+ 100]=S l Dato de registro a memoria
cargar superior nmediaio lui S1,100 >
'100 x 2r6 Carga ctes. en 16 bits superiores
Sa lto
condicional
satar sobre igual beq S1,S2,100 si (S1
= =S2) ir a PC + 4: 100 Test igual; salto relativo al PC
saltar sobre no igual bne S1,S2,1000 s (S1 !=S2) r a PC + 4 - 100 Test no igual; relativo al PC
Inrclailza soore menor c!e slt S1.52.53 si (S2 < S3)$1 = 1
srno5l=u
Compara menor que;
comp. a 2
inicraliza menor que
inmediato
sit S'1,52,100 si
(S2 < 100)51 = 1
srno5t:u
Compara constante menor que;
comp. a 2
inicializa menor que
sin signo
sltu S1,S2,53 si (S2 < 53) 51
:1;
sinoSl=0
Compara menor que; nmero
natural
inicializa menor que lsltu 51,S2.100
nmedato sin signo
si {S2
< 100)St
:'l
si no 51 =0
Compara <
constante, nmero
n atura I
Bifu rcacin
incondicional
bifurcar j 10000 ir a 10000 Bifurca a direccin destino
bif. registro jr
531 ir a S31 Para cambar, vuelta de
proced i m iento
bif. y enlazar
| ;al
10000 S31=PC-4;ira 10000 Para llamada a proced'miento
162
4.5.
Organizacin y diseo de computadores
Construccin de una unidad aritmtico lgica
ALU n.
[Unidad
Artrtca Lgica o (raro) Unidad Aritmtico Lgical Un generador de
ntimeros aleatorios suministrado cono estndar en todos los sistemas comptadores.
Sr.lx Kr-r-y-Boorle, Dicconario DP del Diablo, l98l
La wdad aritnttco lgca o ALU es el msculo del computador, el dispositivo que realiza
las operaciones aritmticas como suma y resta u operaciones lgicas como AND y OR.
En esta seccin se construye una ALU a partir de los cuatro bloques de construccin
hardware mostrados en la Figura 4.7 (vase Apndice B para ms detalles sobre estos
bloques de construccin). Los casos 1, 2 y 4 de la Figura 4.7 tienen dos entradas. A veces
utilizaremos versiones de estos componentes con ms de dos entradas, con la conanza de
que el lector podr generalizar a partir de este ejemplo sencillo. (En cualquier caso, el
Apndice B proporciona ejemplos con ms entradas.)
Como la palabra de MIPS es de 32 bits, necesitamos una ALU de 32 bits. Asumimos
que conectaremos 32 ALUs de I bit para crear la ALU deseada. Por tanto, comenzaremos
construyendo una ALU de 1 bit.
1. Puerta and
(c=
a.b)
2. Puerta or
(c
=
a + b)
a
-.+. I >-+c
b
-/-/
3. Inversor
(c
=
)
a +Drc+ c
4. Multiplexor
(sid==0 c=a;
sino c
=
b)
Figura4.7. Cuatro bloques de construccin hardware utilizados para construir una unidad aritmti-
co lgica. El nombre de la operacin y una ecuacin que la describe aparecen a la izquierda. En medio est
el smbolo del bloque que utilizaremos en los diseos. A la derecha estn las tablas que describen las
salidas en funcin de las entradas. Utilizando la notacn del Apndice B, a
.
b significa
"a
AND b", a + b
significa
.a
OR b., y una lnea sobre la parte superior (por ejemplo, ) significa inversin.
T
"
T;-l
trFF
t;-T;I
FFIF
a b C=?'b
0 0 U
0 0
1 0 0
1
1 I
a b
=A*l
0 0 0
U 1 1
1 0 1
1
1
Una
ALU de 1 bit
Las
operaciones lgicas son
componentes hardware de la
parece a:
ms fciles porque se
Figura 4.7. La unidad
Aritmtica para computadores 163
corresponden directamente con los
lgica de I bit para AND y OR se
Resultado
El multiplexor de la derecha selecciona a AND b o a OR b, dependiendo de que el valor de
Operacin sea 0 1. La linea que controla el multiplexor se muestra en negrita para
distinguirla de las lneas que contienen datos. Observar que hemos renombrado las lneas
de control y de salida del multiplexor para darles nombres que reflejen la funcin de la
ALU.
La siguiente funcin a incluir es la de sumar. A partir de la Figura 4.2 de la p,eina 155
podemos deducir las entradas y salidas de un sumador de un solo bit. Primero. un
sumador debe tener dos entradas para los operandos y una salida de un solo bit para la
suma. Debe haber una segunda salida para transmitir el arrastre. denominada CarrvOut.
Como CarryOut del sumador vecino debe ser incluido como entrada, necesitamos una
tercera entrada. Esta entrada se denomina Carryln La Figura 4.8 muestra las entradas y
las salidas de un sumador de 1 bit. Como sabemos que se va a hacer la suma, podemos
especificar la salida de esta
(caja
negra" basndonos en sus entradas, como muestra la
Figura 4.9.
Del Apndice B sabemos que podemos expresar las funciones de salida CarryOut y
Sum como ecuaciones lgicas, y estas ecuaciones pueden ser implementadas con los
bloques de construccin de la Figura 4.7. Construyamos CarryOut; la tabla siguiente
muestra los valores de las entradas cuando CarryOut es 1:
Entradas
a b Carryln
0 1
1 0 1
I 0
1 1 1
Podemos con\ertir esta tabla en una ecuacin l,eica, como se explica en el Apndice
(recordar que + b signifiea
"r
OR b" y que a
'
b si-enifica
"a
AND b"):
Carr_v-Out
:
(b' Carryln) + (a' Carryln)'t
(a' b) + (a' b' Carrl'ln)
Operacin
164 Organizacin y diseo de computadores
CarrvOut
Figura 4.8. Sumador de 1 bit. Este sumador se denomina sumador completo; tambin se denomna
sumador (3,2) porque tiene tres entradas y dos salidas. Un sumador cuyas nicas entradas son a y b se
denomina sumador (2,2) o semisumador.
Si r
'
b '
Carryln es verdadero, entonces uno de los otros tres trminos debe tambin ser
verdadero, as podemos eliminar el ltimo trmino correspondiente a la cuarta lnea de la
tabla. Podemos, por tanto. simplificar la ecuacin a
CarryOut
:
(b
'Carryln) + (a'Carryln) + (a' b)
La Figura 4.10 muestra que el hardrvare de la caja negra del sumador para Carrl'Out
consta de tres puertas AND y una puerta OR. Las tres puertas AND corresponden
exactamente a los tres trminos entre parntesis de la frmula anterior para CarryOut, y
la puerta OR suma los tres trminos.
Entradas Salidas
Comentarios
a b Carryln GarryOut Sum
0 U U U U 0+0+0:00o"
0 0 1 0 1 0+0+1:016o.
0 1 0 0 1 0 + 1 + 0:'01o.
0 1 1 1 0 0+'l +1:10o.
1 0 0 0 1 1;0-0:010o,
1 U
'I
1
n
1 r- 0 +
'l :
10o.
I 1 0 1 0 1+1+0:100o,
1 1 1 1 1 1+1+1:11o.
Figura 4.9. Especificacin de entradas y salidas para un sumador de 1 bit.
Carryln
A ritm tica pa ra co mp utado res 165
CarryOut
Figura 4.10. Hardware del sumador para la seal CarryOut. El resto del hardware del sumador es la
lgica para la salida Sum dada en la ecuacin anterior.
El bit Sum vale I cuando exactamente una entrada es 1 o cuando las tres entradas
son L Sum se expresa por una ecuacin booleana (recordar que a signica NOT c):
Sum:
@'6' errilnl +
@'
b'evll +
:
ta' 6'Carryln) + (a'b
.Carryln)
El diseo de la lgica para el bit Sum de la caja negra del sumador se deja como ejercicio
para el lector (vase Ejercicio 4.30).
La Figura 4.l1muestra una ALU de 1 bit obtenida combinando el sumador con los
componentes anteriores. A veces los diseadores pueden desear que la ALU realice
algunas operaciones ms sencillas. tal como generar 0 (ceros). La forma ms lcil de aadir
una operacin es expandir el multiplexor controlado por la lnea Operacin y, para este
ejemplo, conectar 0 directe-mente a la nueva entrada de ese multiplexor expandido.
.
CarryOut
Figura 4.11. Una ALU de 1 bit que realiza las observaciones AND, OR y suma (vase Figura 4.10).
166 Organizacin y diseo de computadores
Una ALU de 32 bits
Ahora que hemos completado la ALU de 1 bit, la ALU completa de 32 bits se crea
conectando ..cajas negras>> adyacentes. Utilizando -ti para significar el -simo bit de -r, la
Figura 4.12 muestra una ALU de 32 bits. De Ia misma manera que una sola piedra puede
producir ondulaciones que van hacia las orillas de un lago tranquilo, un simple arrastre de
salida (CarryOut)
del bit menos signicativo (Result0) puede producir una onda que
recorra el sumador, produciendo un arrastre de salida (CarryOut) al bit ms significativo
(Resuit31). Por consiguiente, el sumador creado al enlazar directamente los arrastres de
los sumadores de I bit se denomina sumador de propagacin tle arrastre (ripple carrt').
Veremos una forma ms rpida de conectar ms tarde sumadores de I bit.
Restar es i-eual que sumar la versin negativa de un operando, y as es como los
sumadores realizan la resta. Recordar que la abreviacin para negar un nmero en
Carryln Operacin
Result3l
Figura 4.12. Una ALU de 32 bits construida a partir de 32 ALUs de 1 bit. CarryOut del bit menos
significativo se conecta a Carryln del bit ms significativo. Esta organizacin se denomina de propagacin de
arrastre.
aJl
h?1
Aritmtica para computadores
Operacin
167
Result
CarryOut
Figura 4.13. ALU de 1 bit que realiza las operaciones AND, OR y suma de ay b o ayE. Al seleccionar
b (Binvert = 1) y poniendo a 1 Carryln obtenemos la resta del complemento a dos de b de a en lugar de la
sumadebya.
complemento a dos es invertir cada bit (a veces se denomina contplentento a wto) y despus
sumar 1 (vase Elaboracin de la p*eina 154). Con el frn de invertir cada bit, sencillamente
aadimos un multiplexor 2:1 que escoja entre b y b, como muestra la Figura 4.13.
Suponer que conectamos 32 ALU de 1 bit, como hicimos en la Figura 4.12. El
multiplexor aadido da la opcin de b o su valor invertido, dependiendo de Binvert, pero
esto es slo un paso en la ne,eacin de un nmero en complemento a dos. Observar que el
bit menos signicativo todava tiene una seal Carryln, aun cuando sea innecesaria para
la suma.
Qu
ocurre si Donemos Carryln a 1 en lugar de a 0? El sumador calcular
entonces a
'l
b f 1. Seleccionando la versin invertida de b tenemos exactamente lo
que
oueremos:
a +E+ I
:
a + (6+ 1)
:
a + (-b)
:
a
-
b
La simplicidad del diseo hardrvare de un sumador de complemento
explicar por qu la representacin en complemento a dos ha lle-eado a
universal para la aritmtica entera de los computadores.
a dos
ser el
ay'uda i't
estndar
Confeccin de la ALU de 32 bits para MIPS
Este conjunto de operaciones
-suma.
resta. AND. OR- se encuentra en la ALU de casi
todos los computadores. Pero el diseo de la ALU es incompleto. Si observAlnos la Fi-eu-
ra 4.6 en la pgina 161. r'emos que las operaciones de la ma1'or parte de las insirucciones
168 Organizacin y diseo de computadores
Figura 4.14. ALU de 1 bit que realizaAND, OB y la suma de ay b o 6. Incluye una entrada directa que
se conecta para realizar la operacin de inicializar sobre menor que (vase Figura 4.16).
MIPS las puede rcalizar esta ALU. Una instruccin que todava necesita soportar es la
instruccin inicializar sobre menor que (ser-orr-less-ran). Recordar que la operacin
produce 1 si Rs < Rr, y 0 en otro caso. Consiguientemente,
"inicializar
sobre menor que>
pondr todo a 1 excepto al bit menos signifrcativo a 0. dependiendo del resultado de la
comparacin. As necesitamos expandir el multiplexor para lograr el valor para la compara-
cin <menor que>) para cada bit de la ALU. La Figura 4.14 muestra la nueva ALU de 1 bit
con el multiplexor expandido. Lo que queda por considerar es cmo comparar y poner a I
el bit menos signihcativo para las instrucciones inicializar sobre menor que (ser-on-less-than).
Qu
ocurre si restamos R de Rs? Si la diferencia es negativa. entonces Rs < Rr ya que
(Rs-Rr) <0
-
(Rs-R4+Rr)<(0+Rf)
+ (0+Rs)<(0+Rf)
=>
Rs<Rr
Entonces queremos que el bit menos si-enificativo de <inicializar sobre menor que> sea
I si la diferencia es ne_qativa y 0 si es positiva. Esto tiene una correspondencia exacta con
los valores del bit de signo: I signilica ne-qati\ o
1
0 si-enifica positivo. Siguiendo esta lnea
de argumentacin necesitamos solamente conectar el bit de si-sno de la salida del sumador
al bit menos significativo para obtener lo que queremos.
Desgraciadamente, la salida Result del bit ms signihcativo de la ALU para la opera-
cin
"menor>
no es la salida del sumador: la salida de la ALU para la operacin menor es
el valor de entrada Less
(Menor).
As necesitamos una nueva ALU para el bit ms
signihcativo tal que la salida de la suma est disponible en la salida del resultado estndar.
La Figura 4.15 muestra el diseo. con esta nueva lnea de salida del sumador llamada Set.
Operacin
CarryOut
Aritmtica para computadores
Resu lt
Set
Desbordamiento
CarryOut
Figura 4.15. ALU de 1 bit para el bit ms significativo. Incluye una salida directa del sumador para la
comoaracin sobre menor oue denomnada Set.
Aunque necesitamos una ALU especial para el bit ms signifrcativo, aadimos la l,sica de
deteccin el desbordamiento
(ot'erflow) ya que tambin est asociada a ese bit.
Desgraciadamente. el test sobre menor que es un poco ms complicado de lo descrito a
causa del desbordamiento. El Ejercicio 4.25 de la pgina 232 explora lo que debe hacerse.
La Figura 4.16 muestra la organizacin hnal de la ALU de 32 bits.
Observar que cada vez que queremos que la ALU reste, ponemos Carryln
1'
Binvert
a 1. Para operaciones de suma o lgicas, queremos ambas lneas de control a 0. Podemos
por tanto simplihcar el control de la ALU combinando Carryln y Binvert en una sola
lnea de control llamada Bnegate.
Para extender la ALU al repertorio de instrucciones MIPS. debemos soportar instruc-
ciones de salto condicional. Estas instmcciones saltan o cuando dos registros son i-suales o
cuando no lo son. La forma ms icil para examinar la igualdad con la ALU es restar b de
c y despus hacer un test para ler si el resultado es 0, ya que
(a_b:0) _ a:b
As, si aadimos hardn'are para comprobar si el resultado es 0. podemos examinar la
igualdad. La forma ms senciila es hacer la operacin OR de todas las entradas y'despus
cnviar esa seal Dor un inrersor:
Zero
: (Result-il'-
Result3O + ". * Result2 * Resultl * Result0)
la Fisura 4.17 muestra la .\LU de 32 bits revisada.
169
Operacin
170 Organizacin y diseo de computadores
Operacin
Result0
Resultl
Result2
Result3l
Desbordamiennto
Figura 4.16. ALU de 32 bits construida a partir de 32 ALU de 1 bit como la de la Figura 4.14 y una
ALU de
't
bit como la de la Figura 4.15. Las entradas Less estn conectadas a 0 excepto para el bit menos
significativo, y sa se conecta a la salida Set del bt ms significativo. Si la ALU realiza a
-
b y seleccona-
mos la entrada 3 en el multiplexor de las Figuras 4.14y 4.15, entonces Result
:
0, 001 si a < by 0, y 000
en olro caso.
Ahora que hemos visto qu hay dentro de una ALU de 32 bits, utilizaremos el smbolo
universal para una ALU completa. como muestra la Figura 4.18. Las tres lneas de
Operacin de la ALU, que estn formadas por la combinacin de la lnea Bnegate de 1 bit
I' de la lnea Operacin de 2 bits. hacen que.la ALU realice la operacin deseada: suma.
resta. AND. OR. o inicializar sobre menor que. La Figura 4.19 muestra las lineas de
control
-
la operacin correspondiente de la ALU.
Carryln
ALU2
Less
Aritmtica para computadores 171
Bnegate Operacin
Desbordamiento
Figura 4.1 7. ALU f inal de 32 bits. Esta aade un detector Zero a la Figura 4.1 6, utilizando la ALU de 1 bit.
Anticipacin de arrastre
La siguiente pregunta es:
.Con
qu rapidez puede sumar esta ALU operandos de 32 bits'l
Podemos determinar las entradas a y b (para el bit ms signicativo del sumador se
conocen inmediatamente). pero la entrada Carryln depende de la operacin del sumador
adyacente de 1 bit. Si trazamos todo el camino a travs de la cadena de dependencias.
llegamos al bit menos signiticatilo. as el bit ms signifrcativo de la suma debe esperar la
evaluacin secuencial de los ,ll sumadores de I bit. La reaccin de esta cadena secuencial
es muy lenta para que se utilice en hardrvare de tiempo crtico. Ha1'dirersidad de
esqlemas para anticipar el arrastre para que el escenario en el peor caso sea una luncin
de log, del nmero de bits del sumador. Estas seales anticipatorias son ms rpidas
porque van a trar's de menos puertas en serie. pero necesitan muchas ms puertas en
paralelo para anticipar el arrastre adecuado.
172 Organizacin
y diseo de computadores
Zero
Result
Desbordamiento
CarryOut
Figura 4.18. Smbolo utilizado normalmente para representar una ALU, como muestra la Figu-
ra 4.17. Este smbolo tambin se utiliza para representar un sumador, as que normalmente se rotula con
ALu o Sumador. Las lneas de control rotuladas con OperacinALU incluyen las lneas Operacin y Bnegate
de la Figura 4.17; sus valores y la operacin de la ALU se encuentran en la Figura 4.19.
El Apndice B indica que cualquier ecuacin se puede representar con dos niveles de
lgica, ya que las nicas entradas externas son los dos operandos y Carryln para el bit
menos significativo del sumador. En teora. podramos calcular los valores de Carrl'ln de
los restantes bits del sumador con exactamente dos niveles de |gica.
Por ejemplo, Carryln para el bit 2 del sumador es CarryOut del bit 1 del sumador. as
la frmula es
Carryln2
:
(bl 'Carrylnl) + (al '
Carrylnl) + (al '
bl)
Anlogamente, Carrylnl se deflne como
Carrylnl
:
(b0' Carryln0) * (r0 '
CarrylnO) + (40 '
b0)
Sustituyendo la defrnicin de Carrl'In1 en la primera ecuacin se obtiene la frmula
siguiente, donde ci signica Carrylni:
,2
:
(al. a0' b0) + (41' rz0' c0) + (al' b0' c0)
+ (bl' a0' b0) + (bl'40' c0) + (bl' a0' c0) + (al'
bI)
Lneas de control
de la ALU
Funcin
000 And
001 Or
010 Sumar
110 Restar
111 lnicializar sobre
menor que
Figura 4.1g. Valores de las tres lneas de control Bnegate y Operacin de la ALU y las operaciones
correspondientes de la ALU.
Aritmtica
Para
comPutadores 173
El lector puede imaginar cmo se expande la ecuacin cuando obtengamos bits m_s altos
del sumaor; esta cmplejidad se refleja en el coste del hardrvare para arrastres rpidos,
haciendo este sencillo esquema prohibitivamente caro para grandes sumadores.
La mayor parte de ls esquemas de arrastre rpido limitan la complejidad de las
ecuacionei
pari simplificar el hardware, aunque haciendo todava mejoras sustanciales
sobre la ona de arrastre. Uno de tales esquemas es el smnador de anticipacin de arrastre
(r'arrt-lookaheatl atlder). El primer paso es factorizar algunos trminos comunes de estas
..,roion.r lgicas complejas. Dos factores importantes se denominan generacin
(gi) y
propagacin
(pi\:
a' bi
AIfDI
Los dos trminos estn bien nombrados:
J'
p:
gi
pr
es cierto si el bit
es cierto si el bit
del sumador genera un CarryOut independiente de Carryln:
del sumador propoga un Carryln a un CarryOr-rt.
Carryln, es I si g-r S I o ambos
P-r
eS I y Carryln-r eS I' Utilizando propa-saclon y
g"n.iu.in podemoi expresar las sales de Carryln de forma ms econmica; vemoslo
para 4 bits:
cI:90+(p0.c0)
c2:gI-(pl.90)
c3
:
s2
+ (p2' gl)
c4
:
Q3
+ (p3'
92)
+
tp3'
p2' p.
PO
PI
P2
PJ
'c0)
's0) + (p2
'
sl)
+ (p3
+ (pl
+ (p2
+ (p3
'p0'
'p0
'pl
'
/
v-
c0)
nl nO
r
p2' pl
c0)
e0)
Estas ecuaciones representan exactamente sentido comn: Carry-In, es 1 si alguno de ios
sumadores anteriors genera un arrastre y todos los sumadores intermedios 1o propagan.
Sin embargo, esta frma simplihcada conduce a ecuaciones grandes
Y, Por
tanto, lgica
considerable incluso para un sumador de 16 bits. En el Captulo 1 decamos que los
sistemas de computaor.r t. enfrentaban con la complejidad utilizando niveles de abs-
traccin. Intentemos aqu la abstraccin. Primero coirsideramos este sumador de 4 bits
con su lgica de arrasire anticipado como un solo bloque de construccin. Despus
debemos tner dos posibilidades: o conectar estas abstracciones en forma de propagacin
de arrastre o crear seales de arrastre anticipado para ellas.
Necesitaremos anticipacin de arrastre en el nivel ms alto para correr mas raptdo.
para
realizar la anticipacin de arrastre en sumadores de 4 bits. necesitamos propagar \'
generar seales en est nivel ms aito. Aqui estn para los bloques del sumador de
:1
bits:
p3'p2'pl'p0
p7
'
p6' p5' p4
plI
' pl}' p9 ' p8
pt5
' pI4' pl3
'
pl2
174 Organizacin y diseo de computadores
Es decir, la seal de propagacin para la abstraccin de 4 bits (Pi) es cierta solamente si
cada uno de los bits del grupo propa,sase un arrastre. Anlogamente, la seal de genera-
cin para la abstraccin de 4 bits (Gi) es cierta si todos los bits generasen un arrastre a
partir del bit ms significativo del grupo:
G0
:
s3
+ (p3'
s2)
+ (p3. p2-
sr)
+ (p3. p2. pl
-
s0)
Gl
:
s7
+ (p7
.s6)
+ (p7-p6.95) + (p7
.p6.p5:
s4)
G2
:
glI + (p11
.
s10)
+ (pll
.
plO
-
s9)
+ (p11
.
p10
.
p9. p8)
63
:
sl5
+ (p15
.gl4)
+ (pl5.pr4.gl3) + (p15. pt4- pr3'sr2)
Entonces las ecuaciones en este nivel de abstraccin ms alto Dara un sumador de l6
bits son muy similares a las anteriores:
CL
:
G0 + (P0 c0)
C2
:
GI + (Pl '
G0) + (Pl
'P0 '
c0)
C3
:
G2 + (P2' Gl) + (P:' Pt' G0) + (P2' PI' P0' c0)
C4
:
G3 + (P3 'G2) + (P3'P2 'G1) + (P3'P2 'Pl 'G0)
+ (P3 ' P2' Pl' P0
'
c0)
Los Ejercicios 4.31 a 4.35 exploran las diferencias de velocidad entre estos esquemas de
arrastre, diferentes notaciones para las seales de generacin y propagacin multibits. y el
diseo de un sumador de 64 bits.
Resumen
El punto principal de esta seccin es que la ALU tradicional puede construirse a partir de
un multiplexor y algunas puertas que se replican treinta y dos veces. Para que esto sea
ms til a la arquitectura MIPS, ampliamos la ALU tradicional con hardrvare para
comprobar si el resultado es 0, detectar desbordamiento (oDerflow) y realizar la operacin
bsica inicializar sobre menor que (ser on Iess rlnn).
Elaboracin: La ecuacin lgica para la salida Sum del sumador completo de la pgina 165
puede expresarse de forma ms simple utilizando una puerta ms potente que las AND y OR.
Una puerta OR exclusive es cierta si los dos operandos son distintos; es decir,
x*y + landx:Y::+ 0 .
En algunas tecnologas, la OR exclusive es ms eficiente que dos niveles de puerlas AND y OR.
Utilizando el smbolo
@
para representar la OR exclusive, la nueva ecuacin es:
Sum: a?.b
lCarryln
Ahora hemos contabilizado todas menos una de las operaciones aritmticas y lgicas del
repertorio de instrucciones MIPS: la ALU de la Figura 4.18 omite el sopofie de las instrucciones
de desplazamiento. Seria posible ensanchar el multiplexor de la ALU para que incluya un
desplazamiento a la izquierda de 1 bit o un desplazamiento a la derecha de 1 bit. Pero los
diseadores de hardware han creado un circuito denominado un desplazador (barrel shiftel, que
puede desplazar de 1 a 31 bits sin que importe el tiempo que se necesite para sumar dos
nmeros de 32 bits, as el desplazamiento se hace normalmente fuera de la ALU.
Aritmtica para computadores 175
4.6. Multiplicacn
La multiplicacin es engorrosa, Ia diuisin es mala;
In regla de tres me nriga. t' su prctica me enloquece.
ANNruo, Manuscrito de Ia poca de Ia reina Eli:abeth, 1570
Con la construccin de la ALU
1
la explicacin de suma, resta
)'
desplazamientos estamos
preparados para construir la operacin ms engorrosa de multiplicar.
Pero revisemos primero la multiplicacin de los nmeros decimales realizada a mano
para recordar los pasos y los nombres de los operand.os. Por razones que se aclararn en
breve, limitamos este ejemplo decimal a utilizar solamente los dgitos 0 y l.Multiplicar
1000di". por 1001.,:
Multiplicando
Multiplicador
Producto
1000di",
x
1001
ai".
1 000
0000
0000
1 000
66mm*",
El primer operando se denomina multiplicando y el segundo multiplicador. El resultado
frnal se denomina producto. Como se puede recordar, el algoritmo que aprendimos en la
escuela primaria toma cada vez un dgito del multiplicador. de derecha a izquierda,
multiplica el multiplicando por el dgito correspondiente del multiplicador y coloca el
producto intermedio en el lugar apropiado a la izquierda de los resultados anteriores.
La primera observacin es que el nmero de dgitos del producto es considerablemen-
te mayor que el nmero de dgitos del multiplicando o del multiplicador. En efecto, si
igncramos los bits de signo. la longitud de un multiplicando de r bits y de un multiplica-
dor de rn bits es un producto de n f rn bits. Por consi-suiente. i,eual que en la suma, la
multiplicacin debe resolver el problema del desbordamiento (oterflo*'), porque normal-
mente queremos un producto de 32 bits como el resultado de multiplicar dos nmeros de
32 bits.
En este ejemplo, nos restringimos
dades, cada paso de la multiplicacin
Colocar una copia del multiplicando (1 x
multiplicando) en el lugar adecuado
si el dgito del multiplicador es un 1, o
colocar 0
(0 x
multiplicando) si el dgito es 0.
Aunque en el ejemplo decimal anterior se utilizaban solamente 0 y 1. la multiplicacin de
los nmeros binarios debe utilizar siempre 0 y 1, y por ello siempre ofrece estas dos
posibilidades.
Ahora que hemos rerisado las bases de la multiplicacin. tradicionalmente el paso
siguiente ha sido proporcionar hardrvare de multiplicacin altamente optimizado. Rom-
a los dgitos decimales 0
1'
l. Con slo dos posibili-
es simple:
Multplicando
Desp. izda.
ALU 64 bits
176 Organizacin y diseo de computadores
Figura 4.20. Primera versin del hardware de la multiplicacin. El registro Multiplicando, ALU, y el
regstro Producto son todos de 64 bits, nicamente el registro Multiplicador contiene 32 bits. El multiplicando
de 32 bits comenza en la parte derecha del registro Multiplicando, y en cada paso se desplaza a la zquierda
1 bit. El multiplicador es desplazado en dreccin opuesta en cada paso. El algoritmo comienza con el
producto inicializado a 0. El control decide cundo desplazar los registros Multiplicando y Multiplicador y
cundo escribir nuevos valores en el registro Producto.
pemos con la tradicin en la creencia que el lector tendr una mejor comprensin
observando ia er,olucin del hardware y de los algoritmos de la multiplicacin a lo largo
de tres generaciones. El resto de esta seccin presenta reflnamientos sucesivos del hardrva-
re y del algoritmo hasta que tengamos una lersin que el lector realmente encuentra en un
computador. Por ahora, suponemos que estamos multipiicando slo nmeros positivos.
Primera iteracin del hardware y del algoritmo
de la multiplicacin
El diseo inicial imita el algoritmo que aprendimos en la escuela primaria; el hardrvare se
muestra en la Figura 4.20. Hemos dibujado el hardri'are para que los datos fluyan de
arriba abajo para recordar ms fcilmente el mtodo de papel y lpiz.
Supongamos que el multiplicador est en ei registro lvlultiplicador de 32 bits y que el
registro Producto de 64 bits est inicializado a 0. Como el algoritmo bsico desplaza en
cada paso un dgito a la izquierda al re-eistro \lultiplicando para que pueda ser sumado
en ese paso, al desplazar el valor del multiplicando il bits. pasa de estar alineado a la
derecha a estar alineado a la izquierda, utilizamos un re,eistro Nlultiplicando de 64 bits
con el multipiicando inicialmente en la mitad derecha del registro y ceros en la mitad
izquierdn. Este registro se desplaza en cada paso I bit a la izquierda para alinear el
mrrltiplicando con la suma que est acumulada en el registro Producto de 64 bits.
La Figura.l.2l muestra ios tres pasos bsicos necesarios para cada bit. El bit menos
signilicativo del multiplicador (Multiplicador0) determina si el multiplicando se suma al
registro Producto. El desplazamiento a la izquierda en el paso 2 tiene el efecto de desplazar
los operandos intermedios a la izquierda.
justo
como cuando se multiplica a mano. El des-
plazamiento a la derecha en el paso 3 nos da el'siguiente bit del multiplicador que se examlna
cn la siguiente iteracin. Estos tres pasos se repiten treinta v dos reces para obtener el producto.
Multiplicador0 =
1
S: 32 repeticiones
Multiplicador0
=
0
No: < 32 repeticiones
1a. Suma multiplicando a
Producto
y coloca el resultado
3. Desplaza 1 bit a la derecha
el reqistro MultiPlicador
Artmtca para computadores 177
EJEMPLO
Utilizando nmeros de I bits pirra ahorrar espacio. multiplicar 2di",
X
3i", o 00 l0...
x
0011.'.'
RESPUESTA
La Figura 4.22 muestrr el valrrr de cada registro para cada uno de los pasos rotulados de acuerdc'r
.on la"Figura 4.2l,siendo el ralor nai de OOOO Otl0.,, o 6".. La negrita se utiliza para indic-ar los
yalores
dl registro que cambian en ese paso, y el bit inscrito en un circulo es el que se examina para
dcterminar la operacin del paso siguiente.
Figura 4.21 . El primer algoritmo de la multiplicacin, utilizando el hardware mostrado en la Figu'
ra 4.20. Si el bit menos sigificati'o del multiplicador es 1, sumar el multiplicando al producto' Si no, ir al
paso siguiente. Desplazar-el multiplicando a la izquierda y el multiplicador a la derecha en los dos pasos
siguientes. Estos tres pasos se repiten treinta y dos veces'
178 Organizacin y diseo de computadores
heracin Paso Muhiplicador Muftiplicando Producto
0 Valores iniciales 00@ 0000 0010 0000 0000
1
1a: 1
:
> Prod=Prod+Mcando 001 1 0000 0010 0000 0010
2: Desplaz. izda. Multiplicando 00'r 1 0000 0100 0000 0010
3: Desplaz. dcha. Multiplicador oo0o 0000 01 00 0000 0010
2
1a: 1
:
> Prod=Prod-Mcando 000 1 0000 0100 0000 01 1 0
2: Desplaz. izda. Multiplicando 000 1 0000 1000 0000 01 1 0
3: Desplaz. dcha. Multiplicador 00qo 0000 1000 0000 01 10
1:0:> nooperacin 0000 0000 1 000 0000 01 10
2: Desplaz. izda. Multiplicando 0 000 0001 0000 0000 01 10
3: Desplaz. dcha. Multiplicador oos0 0001 0000 0000 01 1 0
^
1:0:> nooperacin 0000 0001 0000 0000 01 1 0
2: Desplaz. izda. Multiplicando 0000 0010 0000 0000 01
"t0
3: Desplaz. dcha. Multiplicador 0000 0010 0000 0000 0110
Figura 4.22. Ejemplo de multiplicar utilizando el primer algoritmo de la Figura 4.21 .
Si cada paso emplease un ciclo de reloj. este algoritmo necesitara casi 100 ciclos de
reloj para multiplicar. La importancia relativa de las operaciones aritmticas como la
multiplicacin vara con el pro-qrama, pero la suma y resta pueden ser de cinco a cien
veces ms populares que la multiplicacin. Por tanto. en muchas aplicaciones. multiplicar
pLrede emplear mrltiples ciclos de reloj sin alectar signicativamente ei rendimiento. Ya la
le1' de Amdahl (vase Captulo 2. pgina 6i
) nos recuerda que incluso una frecuencia
moderada para una operacin lenta puede limitar el rendimiento.
Figura 4.23. Segunda versin del hardware de la multiplicacin. Comparar con la primera versin de la
Figura4.2O. El registro Multiplicando, ALU, y el reglstro lvlultiplicador son de 32 bits, nicamente el registro
Producto a la izquierda tiene 64 bits. Ahora el producto se desplaza a la derecha. Estos cambios estn
resaltados.
Despl. dcha
Producto
Aritmtica para computadores 179
Segunda iteracin del hardware y del algoritmo
de la multiplicacin
Los pioneros de los computadores reconocan que la mitad de los bits del multiplicando
del primer algoritmo eran siempre 0, as solamente la mitad poda contener valores de
bits tiles. Una ALU de 64 bits entonces pareca antieconmica y lenta ya que la mitad de
los bits del sumador estaban sumando 0 a las sumas intermedias.
El algoritmo original desplaza el multiplicando a la izquierda insertando los 0 (ceros)
en las nuevas posiciones. as los bits menos significativos del producto nunca pueden
cambiar despus de que se ha1''an formado. En lugar de desplazar el multiplicando a la
Figura 4.24. Segundo algoritmo de la multiplicacin, utilizando el hardware de la Figura 4.23. En
esta versin, el registro Producto es desplazado a la derecha en lugar de desplazar el Multiplicando. Lo que
va en negrita muestra los cambios de la Figura 4.21.
Multiplicador0 =
S: 32 repeticiones
MultiolicadorO
=
0
No: < 32 reoeticiones
a la mitad izquierda del producto
Y
coloca el resuhado en la mitad
del reqistro Producto
el registro Multiplicador
180 Organizacin y diseo de computadores
heracin Paso Muttiplcador Muhiplicando Produsto
U Valores iniciales i OOt@ 0010 0000 0000
I
1a: 1
:
> Prod:Prod+Mcando 00r'l 0010 0010 0000
2: Desolaz. dcha. Producto 001 1 0010 0001 0000
3: Desplaz. dcha. Multiplicador
i
000@ 001 0 0001 0000
1a: 1
:>
Prod:Prod+Mcando i
0001 0010 001 1 0000
2: Desolaz. dcha. Producto : 0001 001 0 0001 1000
3: Desplaz. dcha. Multiplicador 00q0 001 0 0001 1000
3
1:0:>noooeracin 0000 0010 0001 1 000
2: Desplaz. dcha. Producto ! 0000 001 0 0000 1
',r
00
3: Desplaz. dcha. Multiplicador 0000) 001 0 0000 1 1 00
1:0:>nooperacin 0000 0010 0000 1 1 00
2: Desolaz. dcha. Producto 0 000 0010 0000 01 1 0
3: Desplaz. dcha. Multiplicador 0 000 0010 0000 0110
Figura 4.25. Ejemplo de multiplicacin utilizando el segundo algortmo de la Figura 4.24.
izqr.rierda, ellos pensaron:
qu
ocurrir si desplazamos el producto ala derecha? Ahora el
multiplicando se hjaria con relacin al producto. y como estamos sumando slo 32 bits. el
sumador necesita tener slo 32 bits. La Figura 4.23 (pgina 178) muestra cmo esre
cambio divide por la mitad las iongitudes de la ALU y del multiplicando.
La Figura 4.24 muestra el al-eoritmo de la multiplicacin inspirado en esta observa-
cin. Este algoritmo comienza con los registros Nlultiplicando y Multiplicador de 32 bits
inicializados con los valores de los nirmeros que se van a multiplicar y el registro
Producto de 64 bits inicializado a 0. Este algoritmo slo forma una suma de 32 bits, as
solamente la mitad izquierda del reeistro Producto de 611 bits se cambia durante la suma.
EJEMPLO
lvf ultiplicar 0010,i,,,
x
0011o, utilizando el algoritmo de la Figura 4.24.
RESPUESTA
La Figura.{1,5 anterior muestra el ejemplo rer.isado de I bits. dando de nuevo 0000 0110,r,.
Versin final del hardware y del algoritmo
de la multiplicacin
La observacin final de los fru-sales pioneros de los computadores fue que en el regislro
Producto se habia desperdiciado un espacio que coincida exactamente con el tamao del
mLrltiplicador: Cuando el espacio desperdiciado en el producto desaparece, tambin des-
iparecen los bits del multiplicador. En respuesta. la tercera versin del algoritmo de la
Aritmtica para computadores 181
Figura 4.26. Tercera versin del hardware de multiplicacin. Comparando con la segunda versin de la
Figura 4.23 de la pgina 178, desaparece el registro Multiplicador separado. El multiplicador se coloca aqui
en la mitad derecha del registro Producto.
multiplicacin combina la mitad derecha del producto con el multiplicador. La Figu-
ra 4.26 muestra el hardrvare. El bit menos signicativo del registro Producto de 64 bits
(Product0) ahora es el bit que se examina.
El algoritmo comienza asignando el multiplicador a la mitad derecha del registro Pro-
ducto, colocando 0 (ceros) en la mitad superior. La Figura 4.27 muestra los nuevos pasos.
EJEMPLO
Multiplicar 0010r.,
x
0011o. utilizando el al-soritmo de la Figura 4.27.
RESPUESTA
La Fieura 4.28 muestra a continuacin el eiemplo revisado de 4 bits
para
el aleoritmo flnal
Multiplicacin con sgno
Hasta aqu hemos tratado con nmeros positivos. La forma ms simple de convertir este
al,soritm para nmeros con si-eno es convertir primero multiplicando y multiplicador a
nmeros positivos y despus recordar los signos originales. El algoritmo debera realizar
entonces 31 iteraciones. dejando los si-snos fuera del ciculo. Como aprendimos en la
escuela primaria, necesitamos negar el producto slo si los signos originales son distintos.
Algoritmo de Booth
Una aproximacin ms elegante para multiplicar nmeros con si-ano es el denominado
Alqoritnto de BLtoth. Comieoza haciendo la observacin de que con la posibilidad de sumar
y restar hay mltiples formrs de calcular un producto. Suponer que queremos multiplicar
2,,", por 6u,". o 0010,,, por 0110.,.:
182 Organizacin y diseo de computadores
Figura 4.27. Tercer algoritmo de la multiplicacin. Slo necesita dos pasos porque los registros Producto
y Multiplicador se han combinado. Lo que va en negrita muestra los cambios con respecto ala Figura 4.24.
+
+
+
+
0010d",
01 10d",
0000 despLaza
(0
en muLtipLi cador)
0010 suma
(1
en muLtipLi cador)
01 00 suma
(1
en muLtipLi cador)
m00 despLaza
(0
en muLtipLicador)
000011 00*,
Booth observ que una ALU que pudiera sumar o restar poda obtener el mtsmo
resultado de ms de una manera. Por eiemplo. como
2:". * 8ai"., o
0010d""
+ 1000",
..
=
-dt
ez
01 1 0d",
=
No: < 32 repeticiones
1a. Suma el multiplcando a la
mitad izquierda del producto y
coloca el resultado en la mitad
del reqistro Producto
S: 32 reDeticiones
Aritmtca para computadores 183
heracin Paso Muhiplicando Produeto
0 Valores iniciales 0010 oooo oolo
1
1a: 1
:
> Prod:Prod+Mcando 001 0 0010 001 1
2: Desplaz. dcha. Producto 0010 oool oo00
2
1a: 1
:
> Prod:Prod+Mcando 001 0 0011 0001
2: Desolaz. dcha. Producto 001 0 0001 10oo
1:0 => nooperacin 0010 0001 1000
2: Desplaz. dcha. Producto 001 0 0ooo 1 100
^
1:0:> nooperacin 001 0 0000 1 1 00
2: Desplaz. dcha. producto 001 0 0000 01 1 0
Figura 4.28. Ejemplo de multiplicacin utilizando el tercer algoritmo de la Figura 4.27.
podemos sustituir una cadena de I {unos) del multiplicador por una resta inicial cuando
veamos primero un I v ms tarde sumamos el bit despus del ltimo uno. Por ejemplo.
X
:
+
+
0010d",
01 10d",
0000 despLaza
(0
en muLtipLicador)
0010 nesta
(primer
1 en muLtipLi cador)
mm desoLaza
(mitad
de cadena de unos)
m1 0 suma
(paso
anteli or tuvo Ltimo 1)
m001100d.,
Booth invent esta aproximacin en una bsqueda de velocidad. creyendo que el
desplazamiento era ms rpido que la suma. En realidad. para algunos patrones su
algoritmo sera ms rpidc: tenemos la suerte que tambin maneja los nmeros con signo.
y lc probaremos ms tarde. La clave de la idea de Booth est en sus grupos de clasiflca-
cin de bits al comienzo. ai medio. o al flnal de una ejecucin de I
(unos):
Fin de ejecucin
Mitad de ejecucin
0t1 11 11 0
Comienzo de eiecucin
Por supuesto, una cadena de 0 (ceros)evita y'a aritmtica. as que podemos dejar stos solos.
Si nos limitamos a obser\ar e\actamente 2 bits, entonces podemos tratar de emparejar
la situacin con el dibuio Drecedente. de acuerdo con los valores de estos 2 bits:
Bit actual Bit a la derecha
I
Explicacin Ejemplo
1 0 Comienzo de eiecucin de unos 00001 1 I 1000do,
1 1 l\4itad de una eiecucin de unos 00001111000d..
0 1
I
Fin de una eiecucin de unos 00001111000co.
0 0 Mitad de una eiecucin de ceros 00001111000do.
184 Organizacin y diseo de computadores
El algoritmo de Booth cambia el primer paso del algoritmo de la Figura 4.27
-obser-
va 1 bit del multiplicador y despus decide si suma el multiplicando- observando 2 bits
del multiplicador. El nuevo primer paso, entonces. tiene cuatro casos, dependiendo de los
valores de los 2 bits. Supongamos que el par de bits examinados estn formados por el bit
actual y por el bit de su derecha
-que
era el bit actual en el paso anterior-. El segundo
paso consiste todava en desplazar el producto a la derecha. El nuevo algoritmo es
entonces:
1. Dependiendo de los bits actual y anterior. hacer uno de lo siguiente:
00 : a) Ivlitad de una cadena de 0 (ceros). ninguna operacin aritmtica.
01 : b) Fin de una cadena de I (unos). suma el multiplicando a la mitad
izquierda del producto.
10: c) Comienzo de una cadena de 1 {unos). resta el multiplicando de la mitad
izquierda del
Producto.
11= d) Ivlitad de una cadena de 1 (unos). ninguna operacin aritmtica.
2. Como en el algoritmo anterior, desplazar el registro Producto I bit a la derecha.
Ahora ya estamos preparados para comenzar la operacin, mostrada en la Figu-
ra 4.29. Comienza con un 0 para el mtico bit a la derecha del bit ms a la derecha de Ia
primera etapa. La tabla siguiente compara los dos algoritmos, el de Booth es el de la
erecha. Observar que la operacin de Booth se identihca ahora de acuerdo con los
valores de los 2 bits. En el cuarto paso los dos algoritmos tienen los mismos valores en el
registro Producto.
Ei irnico requerimiento distinto es que despiazar el producto a la derecha debe
conservar el signo del resultado intermedio. \'r qlle estamos tratando con nitmeros con
si_eno. La solucin es extender el signo cuando el producto se desplaza a la derecha. As, el
piso 2 de ]a primera iteracin convierte 1110 0111 0,ro. en 1111 0011 1o, ell iugar de 0111
b0l1 1u.,,. Esie desplazamiento se denomina despla:antiento aritmtico a Ia derecha para
diferenciarlo de un desplazamiento lgico a la derecha.
Figura 4.29. Comparacin del algoritmo de la Figura 4.27 y el algoritmo de Booth para los nmeros
positivos.
Itera-
cin
Multipli-
cando
Algoritmo original Algoritmo de Booth
Paso Producto Paso Producto
0 0010 Valores iniciales oooo ot r@ Valores iniciales 0000 01 1f0 0
1
001 0 1:0: >no operacin 0000 0110 1a: 00: > no operacin 0000 0110 0
0010 2: Despl. dcha. Producto oooo oo10 2: Despl. dcha. Producto oooo oot6-d
2
0010 1a: 1
:
> Prod
:Prod
+ Mcando 0010 00'r'r 1c: 10= > Prod=Prod-Mcando 1110 0011 0
0010 2: Despl. dcha. Producto 0ooo oo00 2: Desol. dcha. Producto 1111 00
3
001 0 1a: 1
: >Prod
:Prod
+ Mcando 001 1 0001 1d:
'l
1:>nooperacon 1111 0001 1
0010 2: Despl. dcha. Producto oo01 1oo0 2: Despl. dcha. Producto 1111 oo@
A
0010 1:0: >no operacin 000 1 1 000 1b: 01 =
> Prod = Prod + Mcando 0001 1000 1
0010 2: Despl. dcha. Producto 0000 1 1 00 2: Despl. dcha. Producto 0000 1100 0
Aritmtica para computadores 185
Figura 4.30. Algoritmo de Booth con un eemplo de multiplicador negativo.
EJEMPLO
Ensayarel al-eoritmo de Booth con nmeros negativos: 2r".
t
-3.i,..
:
-6",
o 0010u.,.
x
1101.,
:
:
l1 11 1010,jo,.
RESPUESTA
La Figurr J.-10 muestra los prsos.
es posible generalizar el algoritmo
rpidas (vase Ejercicio 4.39).
Nuestro ejemplo calcula
de Booth para r.rtilizar
la multiplicacin de 1 bit cada vez. pero
mltiples bits para multiplicaciones ms
La observacin de Bocth sobre la sustitucin de la aritmtica por desplazamientos
puede aplicarse cuando se multiplica por constantes. Algunos compiladores sustitu-
yen las multiplicaciones por pequeas constintes por Lrna serie de desplazamientos,
slimas y restas. Debido a que I bit a la izquierda representa el doble de un n[tmero
en base 2. el desplazamiento de bits a la izquierda tiene el mismo efecto que
multiplicar por una potencia de 2. as casi todos los compiladores sustituirn un
desplazamiento a la izq'.rierda por una multiplicacin por una constante que sea una
potencia de 2.
EJEMPLO
NI ultipliquemos
RESPUESTA
Dado que
nnr ' utilizando un desplazamiento a la izquierda de l.
-
il
-
t0
x -r (l x
f").ii",
:
+
-
0
-
Iteracin Paso Multiplicando Producto
0 Valores iniciales 001 0 oooo 11@
1
1c: 10= > Prod: Prod
-Mcando
001 0 1110 i101 0
2: Desplaz. dcha. Producto 001 0 1111 0110-Jl
1b: 01
:
> Prod: Prod + Mcando 001 0 0001 0110 1
2: Desolaz. dcha. Producto 001 0 1111 101@
1c: 10: > Prod: Prod
-
Mcando 001 0
'1110
1011 0
2: Desolaz. dcha. Producto 0010 1111 01@
A
1d: 11= >no operacin 001 0 11110101 1
2: Desplaz. dcha. producto 001 0 1111 1010 1
186 Organizacin y diseo de computadores
si desolazamos un bit a la izquierda obtenemos
v
Por consiguiente, la
de 2.
:
(l x
2r) + (0 x
2r) + (l x
2') + (0 x
20)di",
:8+0+2*0.,:10r.,
5
x
2ir",:10i.,
MIPS s L L puede ser utilizada para multiplicar por potencias
Para multiplicaciones reales, MIPS proporciona un par separado de registros de
32 bits para almacenar el producto de 64 bits. llamados Hi y Lo. Para producir un
producto con el signo adecuado o sin signo, \IPS tiene dos instrucciones: multipli-
car (muLt) y multiplicar sin signo (muLtu). Para buscar el producto normal de 32
bits, el programador utiliza transJerr desde Io
Qnote fronr
/o) (mflo). El ensamblador
MIPS permite en las instrucciones de multiplicar especihcar tres registros, facilitan-
do las instrucciones mf Lo para colocar ios productos en los registros.
Ambas instrucciones de multiplicar ignoran el desbordamiento, as que el softrva-
re debe encargarse de comprobar si el producto es muy grande para que coja en 32
bits. Para evitar el desbordamiento, Hi debe ser 0 para muLtu o debe ser el signo
replicado de Lo para muLt. La instruccin transferir desde h
Qnoue from
/rt) (mfhi)
transflere Hi a un registro para realizar un test sobre desbordamiento.
Ahora que hemos visto cmo funciona el algoritmo de Booth, estamos listos para ver
por qt funciona para los enteros con signo en complemento a dos. Sea n el multiplicador
y b el multiplicando, utilizaremos apara referirnos al bit de a. Expresando el algoritmo
de Booth en funcin de los valores de los bits del multiplicador obtenemos esta tabla:
d ?it Operacin
0 0 No hacer nada
0 I Sumar b
'l
0 Restar b
1 1 No hacer nada
En lugar de representar el algoritmo de Booth en forma tabular, podemos representarlo
como la expresin:
(a,-,
-
a,l
donde el valor de la expresin signifrca las siguientes acciones:
0 no hacer nada
+ I sumar b
-
I restar b
Aritmtica para computadores 187
Como sabemos que el desplazamiento del multiplicando a la izquierda con respecto al
registro
Producto puede considerarse multiplicar por una potencia de 2, el algoritmo de
Booth
puede escribirse como la suma:
(a-,
-
ao)
x
b
-
(ao-ar)xbx/r
I
(ar-a)xbx22
:
(azg- 4o)xbx23o
-
(ao-ar) xbx23l
Podemos simplicar esia suma observando que
-a
X
2i-r + a
x
2i
:
l-a + 2a,)
x )-L :
(2a
-
ai)
a
2i-r
:
a
x
2i-l
y sacando factor comn b en cada trmino:
b
* ((at, x
-23t)
+ (nro *
2'0)'t (azs x
22e) + "' + (a, x
2') i (co x
l0
Lr frmula larga entre parntesis a la derecha de la primera operacin de multiplicar es
simplemente la representacin en complemento a dos de a (vase p_eina 150). Entonces la
suma se simplifrca a
bxa
Por consiguiente, el algoritmo de Booth realiza, en efecto, la multiplicacin en comple-
mentoadosdeayb.
Resumen
La multiplicacin ia realiza un hardrvare sencillo de desplazamiento y suma, basado en el
mtodo de papel y lpiz aprendido en la escuela primaria. Los compiladores sustituyen
incluso las multiplicaciones por potencias de 2 por instrucciones de desplazamiento. La
multiplicacin con si-gno es ms dicil, el algoritmo de Booth despeja esta dihcultad
realizando una factorizacin inteligente de la representacin numrica en complemento a
dos del multiplicador.
Efaboracin: La razn original del algoritmo de Booth fue la velocidad, porque las primeras
mquinas realizaban los desplazamientos con ms rapidez que las sumas. La esperanza fue
que este esquema de codificacin incrementara el nmero de desplazamientos. Sin embargo,
este algoritmo es sensible a patrones particulares de bits, y realmente puede incrementar el
nmero de sumas o restas. Por ejemplo, patrones de bits que alternan 0 y 1, denominados
1 (unos) aislados, hacen que,el hardware sume o reste en cada paso. Si todas las combinacio-
nes se presentan con una distribucin uniforme, entonces en promedio no hay ahorros. La mayor
ventaja proviene de realizar mltiples bits por paso, lo que exploramos en el Ejercicio 4.39.
188 Organizacin y diseo de computadores
4.7. Divisin
Dde et impera.
"Divide
y vencers> en latn. antigua mxima politica citada por Maquiaveio, 1532
La operacin recproca de la multiplicacin
es la divisin, una operacin an menos
frecuente e incluso ms peculiar. Adems-ofrece
la oportunidad de rlizar una ope.acin
no vlida matemticamente:
dividir
por
0.
Comencemos con un ejemplo de divisin utilizando nmeros decimales para recordar
los nombres de los opera.ndos y el algoritmo de divisin de la escuela
irimaria.
por
razones anlogas a las de l seccin anterior. limitamos los di-eitos decimales al 0 l. El
ejemplo es dividir 1.001.01Odi". por 10006".:
1001,ii., Cociente
Divisor 1000,ri", fmmm*. Dividendo
-
1000
l0
101
t0l0
-
1000
10.,.. Resto
Los dos operandos (diuidendo y ditisor)
1'
el resulta d,o (cociente)
de la divisin van
acompaados de un segundo resultado denominado resto. Hay otra forma de expresar la
relacin entre los componentes:
Dividendo
:
Cociente x
Divisor + Resto
donde el Resto es menor que el Divisor. Infrecuentemente,
los pro-sramas
utilizan la
instruccin de dividir para
obtener el resto. i-snorand el cociente. obseivar que el tamao
del dividendo est limitado por la suma de lcs tamaos del divisor y del cciente.
El al-eoritmo de divisin de la escuela primaria trata de ver cuntas veces puede ser
restado un ntmero, creando en cada intento un d-eito del cociente. Nuestro ejemplo
decimal cuidadosamente seleccionado utiliza solamete los nmeros 0 y l. as es fcil
determinar cuntas veces el divisor cabe en la parte del dividendo: es o .ro u..., o una
vez. Los nmeros binarios contienen slo 0 1. as la divisin binaria est restrin*eida a
estas dos posibilidades, por esa razn se simplifica la dir,isin binaria.
Tradicionalmente los libros de texto van al hardrvare de refinado de la divisin v.
nuevamente, abandonamos la tradicin para explicar cmo ha evolucionado el hardrvar.
Las tres subsecciones si-euientes examinan trei versiones
del algoritmo de la divisin,
rellnando los requerimientos hardrvare cuando a\-anzamos. Supon_eamos que dividendo y
dirisor son positivos y por consi_guiente el cociente
],resto
son no neeativos.
Aritmtica parc computadores 189
Primera iteracin del hardware y del algoritmo
de la divisin
La Figura 4.31 muestra el harduare que imita nuestro algoritmo de la escuela primaria.
Comenzamos con un resistro Cociente de 32 bits inicializado a 0. Cada paso del algorit-
mo necesitr desplazar el divisor a la derecha un dgito, comenzamos asi con el divisor
situado en la mitad izquierda del registro Divisor de 64 bits y en cada paso lo desplaza-
rnos un bit a la derecha para alinearlo con el dividendo.
La FigLrra
-1.32
muestra tres pasos del primer algoritmo de la dirision. De formr
distinta a las personas. el computador no es lo suliciente inteligente para saber por
anticipado si el divisor es ms pequeo que el dividendo. Primero debe restar el dii isor en
cl paso 1; recordar que as hacamos la comparacin en la instruccin inicializar sobre
n.renor que (ser-on-less-thcutl. Si el resultado es ne-gativo. el siguiente paso es restaurar el
valor original volriendo a sumar el divisor ai resto
(paso
2b). El resto r cociente se
encontrarrn en sus registros homnimos despus que se completan las iteraciones.
EJEMPLO
l-tilizando una versin de I bits del algoritmo para ahorrar pginas, intentar dividir 7r,-, por 2u", o
0000 011Ie* por 00i0c.,,.
RESPUESTA
La Figtrra 4.33 muestra el ialor de cada registro en cada uno de los pasos. siendo el cociente
-l., )
el resto 1",. Observar que el test del paso 2 para ver si el resto es positivo o negativo simplemente
cxrminr si el bit del registro Resto es 0 o l. El requerimiento sorprendente de este algoritmo es que
necesita rr * i pasos para obtener el cociente
]'
resto adecuados.
Figura 4.31. Primera versin del hardware de la divisin. El registro Divisor. ALU y registro Resto son
todos de 64 bts, nicamente el registro Cociente tiene 32 bits. El divisor de 32 bits se encuentra en la mitad
izquierda del registro Divisor y en cada paso se desplaza 1 bit a la derecha. El resto se inicializa con el
dividendo. El control decide cunco Cesplazar los registros Divisor y Cociente y cundo escribir el nuevo
valor en el reqistro Resto,
Divisor
^^^t ^L^
ugJpr. uu ro.
R esto
Escribir
190 Organzacin y diseo de computadores
Figura 4.32. El primer algoritmo de divisin, utilizando el hardware de la Figura 4.31 . Si Resto es
positivo, el divisor cabra en el dividendo, as el paso 2a genera un 1 en el cociente. Un resto negativo
despus de este paso significa que el divisor no cabe en el dividendo, as el paso 2b genera un 0 en el
cociente y suma el divisor al resto, invirtiendo as la resta del paso 1. El desplazamiento final, en el paso 3,
alinea adecuadamente el divsor, con respecto al dividendo para la iteracin siguiente. Estos pasos se
repiten treinta y tres veces; la razn del paso extra aparente se aclarar en la siguiente versin del
alooritmo.
No: < 33 reoeticiones
l. Resta el registro Divisor del
regstro Resto y coloca el
resultado en el registro Resto
2b. Restaura el valor original
sumando el registro Divisor al
registro Resto y coloca la suma
en el registro Resto. Tambin
desplaza el registro Cociente a la
izquierda inicializando a 0 el nuevo bit
menos significativo
2a. Desplaza el registro Cociente
a la izquierda inicializando a 1 el
nuevo bit ms a la derecha
Resto
>
0
S: 33 reoeticiones
Aritmtica para computadores 191
Iteracin
Paso Cociente Divisor Resto
0 Valores iniciales
0000 0010 0000 0000 01 1 1
I
1: Res = Res
-
Div
0 000 0010 0000
@rro
ottt
2b: Res<O =
>
-Div,
sll Q, Q0:0 001 1 0010 0000 0000 01 1 1
3: Desplaz. Div. dcha. 0000 0001 0000 0000 01 1 1
1: Res: Res
-
Div 0000 0001 0000
@rrt
ottt
2b: Res<0
:
>
-Div,
sll Q, O0:0 0000 0001 0000 0000 01 1 1
3: Desolaz. Div. dcha 0000 0000 1000 0000 01 1 1
1: Res: Res
-
Div
0000 0000 1 000
@rrr
tttt
2b: Res<0
:
>
-Div,
sll O, O0:0 0000 0000 1000 0000 01 1 1
3: Desplaz Div. dcha.
0000 0000 0100 0000 01 1 1
^
1: Res: Res
-
Div
000 0 0000 01 00
@oo
oot t
2a: Res<0
:
> sll O. Q0:1 0 001 0000 01 00 0000 00 1 1
3: Desolaz. Div. dcha.
000 1 0000 0010 0000 001 1
5
'l
: Res: Res
-
Div
000 1 0000 0010
@oo
ooot
2a: Res<O
:
> sll Q, O0= 1 001 1 0000 0010 0000 000 1
3: Desplaz. Div. dcha.
001 1 0000 0001 0000 0001
Figura 4.33. Ejemplo de divisin utilizando el primer algoritmo de la Figura 4.32.
Segunda versn del algoritmo de divisin
y hardware
Una vez ms, los fru-eales pioneros de los computadores reconocieron que, como mximo'
la mitad del divisor tena informacin til, y as divisor y ALU podan dividirse potencial-
mente por la mitad. Al desplazar ei resto a la izquierda en lugar de desplazar el divisor a la
derech se produce la misma alineacin y se logra el objetivo de simplihcar el hadrvare
necesario pira la ALU,v el dirisor. La Figura 4.34 muestra el hardware simplificado
para
la segunda versin dei algoritmo.
L se_eunda mejora pror,iene de observar
que el primer paso del algoritmo actual no
puede prducir un 1 en el bit del cociente; si 1o hiciese, entonces el cociente seria muy
grande'para el re-eistro. Cambiando el orden de las operaciones
para desplazar
1'
despus
i.rt^r, sL puede.li*inu, una iteracin del algoritmo. La Figura 4.35 muestra'los cambios
de este algoritmo refinado de la dilisin. El resto se encuentra ahora en la mitad izquierda
del reeistro Resto.
EJEMPLO
Dividir 0000 0l11oo, por 0010,j... utilizando el algoritmo de la Figura 4.35.
RESPUESTA
Lr respuesta se resume en la Figura -1.36.
't92
Organizacin y diseo de computadores
Cociente
Despl. izda.
32 bits
Figura 4.34. Segunda versin del hardware de divisin. El registro Divisor, ALU y registro Cociente
son de 32 bits, solamente el registro Resto tiene 64 bits. Comparado con la Figura 4.31, la ALU y el
registro Divisor se han dividido por dos y el resto se desplaza a la izquierda. Estos cambios estn
resaltados.
Versin final del hardware y del algoritmo
de la divisin
Con la misma intencin y motivacin que en la tercera versin del algoritmo de la
multiplicacin, los pioneros de los computadores vieron que el registro Cociente poda
eliminarse desplazando los bits del cociente al resto en lugar de desplazar 0 (ceros) como
en el algoritmo precedente. La Figura 4.37 muestra la tercera versin del algoritmo.
Comenzamos el algoritmo desplazando el resto a la izquierda como antes. Despus de eso,
el bucle slo contiene dos pasos porque el desplazamiento del registro Resto desplaza
al resto en la mitad izquierda y al cociente en la mitad derecha (vase Figura 4.38).
La consecuencia de combinar los dos registros y el nuel'o orden de las operaciones en el
bucle es que el resto se desplazar una posicin a la izquierda muchas veces. As el paso
final de correccin debe volver a desolazar solamente el resto en la mitad izouierda del
registro.
EJEMPLO
Utiliza la tercera vesin del algoritmo para diridir 0000 0i11r... por 0010J.,,.
RESPUESTA
La Figura 4.39 muestra cmo se crea
arnbos son desplezados l la izqLrierda
el cociente en el ertremo inferior del reeistro Resto v cmo
en una sola operacin.
Aritmtica para computadores 193
Figura 4.35. Segundo algoritmo de la divisin, utilizando el hardware de la Figura 4.34. De forma
distinta al primer algoritmo de la Figura 4.32, solamente se cambia la mitad izquierda del resto, y el resto se
desplaza a la izquierda en lugar de desplazar el divisor a la derecha. La negrita muestra los cambios de la
Fioura 4.32.
No: < 32 repeticiones
'1.
Desplaza 1 bit a la izquierda
el registro Resto
2. Resta el registro Divisor de
la mitad izquierda del registro Resto
y coloca el resultado en
la mitad izquierda del registro Resto
3b, Restaura el valor original sumando el
registro Divisor a la mitad izquierda del
registro Resto y coloca la suma en la mitad
izquierda del registro Resto.
Tambin desplaza el registro Cociente a la
izquierda, inicializando a 0'el nmero bit
menos significativo
3a. Desplaza el registro Cociente
a la izquierda inicializando a 1
el nuevo bt ms a la derecha
S: 32 reoeticiones
heracin Paso lente'
Divisor Resto
0 Valores iniciales 0000 001 0 0000 01 1 1
1
l: Desolaz. Bes izda. 000 0 001 0 0000 1110
2: Res:Res-Div 0000 001 0
@rro
rrro
3b: Res<O
:
> +Div, sll O, O0=0 0 000 001 0 0000 1110
2
1: Desplaz. Res izda. 0000 001 0 0001 1 1 00
2: Res: Res
-
Div 0000 001 0
@rrr
rroo
3b: Res<0
:
> +Div, sll O, O0:0 000 0 0010 0001 1 1 00
1: Desplaz. Res izda. 000 0 001 0 0011 1000
2: Res: Res
-
Div 0000 001 0
@or
r ooo
3a: Res 0 =
> sll O. O0:1 000'l 001 0 0001 1000
1: Desplaz. Res izda. 000 1 0010 001 1 0000
2: Res: Res
-
Div 000 1 0010
@or
oooo
3a: Res 0
:
> sll O, O0:1 001 1 001 0 0001 0000
194 Organizacin y diseo de computadores
Figura 4.36. Ejemplo de divisin utilizando el segundo algoritmo de la Figura 4.35.
Divisin con sgno
Hasta ahora hemos ignorado los nmeros con signo en la divisin. La solucin ms
simple es recordar los signos del divisor y dividendo y despus negar el cociente si los
signos no coinciden.
La nica complicacin es que tambin debemos determinar el signo del resto. Recor-
dar que la ecuacin siguiente debe cumplirse siempre:
Dividendo
:
Cociente
x
Divisor + Resto
Para comprender cmo determinar el signo del resto, observemos el ej'emplo de dividir
todas las combinaciones de 76., pot 2d... El primer caso es fcil:
+7
'.
*2: Cociente
:
*3. Resto
:
*1
Comprobando los resultados:
7
:
3
x
2 + (*l) :
6 + 1
Si cambiamos el signo del dividendo. el qociente tambin debe cambiar:
-7
+ *2: Cociente
:
-3
1. Desplaza a la izquierda 1 bit
el registro Resto
2. Resta el registro Divisor de
la mitad izquierda del registro Resto
y coloca el resultado en la
mitad izquierda del registro Resto
3b. Restaura el valor original sumando el
registro Divisor a la mitad izquierda del
registro Resto y coloca la suma en la mitad
izquierda del registro Resto.
Tambin desplaia a la izquierda el regstro
Resto, inicializando con 0 el nuevo bit ms a
la derecha
3a. Desplaza el regstro Rsto
a la izquierda, inicializando a 1
el nuevo bit ms a la derecha
Realizado. Desplaza 1 bit la mitad
izquierda del Resto
Resto
>
0
Si: 32 repeticiones
Aritmtica para computadores 195
Figura 4.37. El tercer algorito de la divisin tiene exactamente dos pasos. El registro Resto se
desplaza a la izquierda, combinando los pasos 1 y 3 en la Figura 4.35 de la pgina 193.
196 Organizacin y diseo de compactores
Figura 4'38. Tercera versin der hardware de ra divisin. Esta versin combina el
la mitad derecha del registro Resto.
Reescribiendo
nuestra frmula
bsica para calcular el resto:
Resto Dividendo
-
Cociente x
Divisor
- -7 -
(+3 x
-f)
:
-7 -
(-6) : _t
As,
-7
+ f 2: Cociente
-
_3,
Resto
: _l
Comprobando
los resultados
de nuevo:
-7 -
-3
x
2 + (-l)
=
-6 -
I
registro Cociente con
Despl. izda.
esto
trscn br
Iteracin
Paso
Divisor
Resto
0
Valores iniciales
001 0 0000 01 1 1
Desplaz. Res izda. 1
0010 0000 1110
I
1: Res:Res-Div
0010
@ot
rrio
2b: Res<O : >
-Div, sll R, R0:0
001 0 0001 1 100
z
1: Res: Res
-
Div
0010
@rrt
rroo
2b: Res<O :
> +Div,
sll R. R0:0
0010
001 1 1000
?
1: Res
= Res
-
Div
0010
@or
rooo
2a: Res 0
=
> sll R. RO:'l
001 0 001 1 0001
4
'l
:'Res: Res
-
Div
0010
@or
ooor
2a: Res 0 =
> sll R, R0:1
0010
0010 001 1
Mitad izda. de Res 1 a fa dcha.
0010
0001 oo1 1
I
Figura 4.39. Ejempro de divisin utirizando er tercer argoritmo de ra Figura 4.32.
Aritm tica pa ra co m p utado re s 197
Larazon
por la que la respuesta no es un cociente de
-4
y un resto de * 1, que tambin
cumplira
esta frmula, es que el cociente y resto deben tener los mismos valores absolutos
sin
importar los signos del dividendo y divisor.
Claramente
si
-(-x - -r')
(--r)
= 1'.
5 I 0
0 01111111110
10000000000000000000
00000000 1 00000000000000000000000
32
EJEMPLO
Qu
nmero decimal representa esta palabra.
RESPUESTA
El bit de signo es 1. el campo de exponente contiene 129, y el campo de mantisa contiene
I
x 2-2
:
lll 0.25. Utilizando la ecuacin bsica:
(-1)t * (1 4 mantisal
x )re\ponente-dcsplrzrmiento)
-
:
(-1)t r
ll
+ 0.25)
r(r3e-t21r
-1
x 1.25
x
2l
-
1.25
x -1
-
5.0
En las siguientes secciones daremos los algoritmos de suma y multiplicacin en punto
flotante. Enisencia. urilizan las operaciones enteras correspondientes sobre las mantisas.
pero es necesario un mantenimiento extra para manipular_los exponentes y normalizar el
iesultado. Primero darenios una aproximacin intuitiva de los algoritmos en decimal. r'
despus daremos una r ersin binaria ms detallada de las ltguras.
31 30 29 28 27 o za 24 5 22 21 20 19 18 17 to 14 13 t l1 10 I
1
5 4 2 1 0
1 1 O O O o O o l
lo
1 o 0 o o 0 o o o o o 0 0 o o o o o o
204 Organizacin
y diseo de computadores
Elaboracin: En un intento de incrementar el rango sin eliminar bits de la mantisa, algunos
computadores antes del estndar IEEE 754 utilizaron una base distinta de 2. Por ejemplo, los
grandes computadores IBM 360 y 370 utilizan base 16. Como cambiar el exponente IBM en
'1
significa desplazar la mantisa 4 bits, nmeros en base l6.normaliz6" puedn tener hasta 3
bits de comienzo igual a 0. Los dgitos hexadecimales significan que de la mantisa deben
eliminarse hasta 3 bits, lo que conduce a problemas sorprendentes en la precisin de la
aritmtica de punto flotante, como se seala en la seccin de Perspectiva histrica de la pgi-
na 219.
Suma en punto flotante
Sumemos nmeros en notacin cientfrca a mano
para
ilustrar el
problema
de la suma en
punto flotante:
g.gggdi,.
x
101 + 1.610di..
x
i0-
t.
Supon-eamot qu. queremos almacenar
solamente cuatro dgitos decimales de la mantisa v dos dgitos decimales del exponente.
Paso l. Para poder sumar estos nmeros adecuadamente, debemos alinear el punto
decimal del nmero con el exponente ms pequeo. Por consiguiente, necesi-
tamos una forma del nmero ms pequeo, 1.6100",
x
10-r, que correspon-
da al mayor exponente. Obtenemos esto observando que hay mltiples
representaciones de un nmero no normalizado en notacin cientifica en
punto flotante.
1'61Odi.,
x
10-r
:
0.1610..
x
100
:
0'01610,:.,
x
10-r
El nmero de la derecha es la versin que deseamos. ya que su exponente
coincide con el exponente del nmero mayor 9.999di,,
x
101. Por tanto, el
primer paso desplaza la mantisa del nmero ms pequeo a la derecha hasta
que su exponente corregido coincida con el del nmero mayor. Pero pode-
mos representar slo cuatro d-eitcs decimales, as, despus del desplazamien-
to, el nmero es realmente:
0'016di",
"
.10t
Paso 2. A continuacin se realiza la suma de las mantisas:
9.999di,.
0.016di",
I 0.01 5di.,
La suma es 10.015u,",
x
lOt
Paso 3. Esta suma no est en notacin cientflca normalizada. por ello necesitamos
corregirla. De nuevo, hay mltiples representaciones de este nmero; escoge-
mos la forma normalizada:
10.015di..
x
10I:1.0015u'..
x
-r
Aritmtica para computadores 205
Por tanto. despus de realizada la suma quiz haya que desplazarla para
ponerla en lorma normalizada, ajustando adecuadamente el exponente. Este
ejemplo muestra el despiazamiento a la derecha. pero si un nmero fuese
positivo
'
el otro fuese negativo, sera posible que la suma estuviese precedi-
da por muchos 0
(ceros), necesitando desplazamientos a la izquierda. Siem-
pre que el erponente aumente o disminuya, debemos comprobar el desbor-
damiento
(oter-lou'\ o desbordamiento a cero (tmderJlon')-es decir, debemos
estar seguros que el exponente cabe perfectamente en su campo.
Paso 4. Como suponiamos que la mantisa poda tener solamente 4 d-eitos 1exclu1'en-
do el signo). debenios redondear el nrmero. En nuestro algoritmo de la
escuela printaria. las reglas truncan el nmero si el dgito a la derecha del
punto deseado est entre 0 y 4 y suman 1 al dgito si el nmero a la derecha
est entre 5 v 9. El nmero
1.0015di",
x
102
se redondea a cuatro deitos en la mantisa a
1.002di",
x
102
ya que el cuarto dgito a la derecha del punto decimal estaba entre 5 y 9.
Observar que si tenemos mala suerte en el redondeo. tai como sumar 1 a una
cadena de 9
(nueyes). la suma puede no estar normalizada
i'
sera necesario
realizar de nuevo el paso 3.
La Figura 4.41 muestra el algoritmo para ia suma binaria en punto flotante que sigue
er este ejemplo decimal. Los pasos 1 y 2 son similares al ejemplo ahora explicado: aJustar
la mantisa del nmero con el erponente ms pequeo y despus sumar las dos mantisas-
El paso 3 normaliza los resultados. forzando a una comprobacin para el desbordamiento
(ou'erflotv) o desbordamiento a cero (wuluJlow). El test del paso 3 depende de la precisin
de ls operandos. Para simple precisin. el mximo exponente es 127 y el mnimo
-
126.
Los lmites para ooble precisin son 1.023 y
-
1.022.
Por simplicidad, mostraremos la truncacin en el paso 4, una de 1as cuatro opciones
de redondeo del punto flotante del IEEE 154. La p.recisin de los clculos en punto
flotante depende en gran nredida de 1a precisin del redondeo, as. aunque fcil seguir. la
truncacin nos aleja de la precisin.
EJEMPLO
Tratar de sumar los nmer..s 0.-i,
r1 +.41.
r
-
0.437,5i", en binario utilizando el algoritmo de la Fi-eu-
RESPUESTA
Examinemos primero la rersi'.n binaria de los dos nitmeros en notacin cientficr normalizada.
suponiendo que tenemos '1 bis de precisin:
Organizacin y diseo de computadores
Figura 4.4'1 . Suma en punto flotante. El camino normal es ejecutar los pasos 3 y 4 una vez. pero si el
redondeo hace oue la suma est sin normalizar, debe reoetirse el oaso 3.
1. Comparar los exponentes de los dos
nmeros. Desplazar el nmero menor a la
derecha hasta que su exponente coincida con
el exponente mayor
3. Normalizar la suma, o desplazar a la derecha e
incrementar el exponente o desplazar a la
izquierda y decrementar el exponente
4. Redondear la mantisa al nmero de
bits apropiado
Aritmtca para computadores 2O7
0.5". = lf 2i",
:
ll2t
".
:
0.loo,
:
0.10o.
x
20
:
1.000o, x
2-t
-0.4375di,,: -7
16",
:
-72tr",
:
-0.0111d.,,
:
-0.0111o,
x
20
:
-
1.110d", x
2-2
Ahora seguimos el algoritmo:
Paso l. La mantisa del nmero ms pequeo (- l.lldo. x
2-2) se desplaza a Ia derecha hasta
que su exponente coincida con el nmero mayor:
-
l.ll0do,
x
2-2
:
-0.111o,
x
l-r
Paso 2. Sumar las mantisas:
1.0o.
x
2-t + (-0.llldo, x
2-t): 0.001.* x
2-r
Paso 3. Normalizar la suma. comprobando el desbordamiento (ocerflort) o el desbordamiento a
cero
QmderJlo*'\:
0.001o,
x
2-r
:
0.010do,
x
2-2: 0.100..
x
2-3
:
1.000o,
x
2-1
Como 127 > -4
>-
-126,
no hay oterflow ni wtdaflow. (El exponente desplazado
seria
-
4 + I27 I23, que est entre 0 y 255, los exponentes mrimo
1'
mnimo
desplazados.)
Paso 4, Redondear la suma:
1.000do,
x
2-1
La suma ya coge en -l bits, asi que no hay necesidad de redondear.
Esta suma es entonces:
1.000o.
x
2-+
:
0.0001000o,
:
0.0001o,
:
I.i2o".
:
lf 16,",: 0.0625".
Esta suma es la que esperaramos sumando 0.5u,., a
-
0.4375di",
Nluchas mquinas dedican hardrvare a correr operaciones en punto flotante tan rpido
como es posible. La Figura 4.42 presenta un esquema de la organizaci bsica del
hardware para la suma en punto flotante.
Multiplicacin en punto flotante
Ahora que hemos explicado la suma en punto flotante, tratamos la multiplicacion cn
punto flotante. Comenzamos multiplicando nmeros decimales en notacin cientllca a
mano: 1.11Odi".
x
1010
x'
9.100i.,
x
10-
s.
Suponemos que podemos almacenar sirlt'r
cLlatro di-sitos de la mantisa
)
dos digitos del exponente.
208 Organizacin y diseo de computadores
Figura 4.42. Diagrama de bloques de una unidad aritmtica dedicada a sumar en punto flotante. Los
pasos de la Figura 4.41 corresponden a cada bloque, desde la parte superior hasta la inferior. Primero el
exponente de un operando se resta del de otro utilizando la pequea ALU para determinar cul es mayor y
en cunto. Esta diferencia controla los tres multiplexores; de izquierda a derecha selecciona el exponente
mayor, la mantisa del nmero ms pequeo, y la mantisa del nmero mayor. La mantisa ms pequea se
desplaza a la derecha y despus las mantisas se suman
juntas
utilizando la ALU grande. El paso de
normalizacin despus desplaza la suma a la izquerda o a la derecha e incrementa-o decrementa el
exponente. El redondeo crea entonces el resultado final.
Paso 1. De forma distinta a la suma, calculamos el exponente del producto sumando
sencillamente los exponentes de los operandos iuntos:
Nuevo exponente
:
10 + (- 5)
:
5
Tambin hacemos esto con los erponentes desplazados para asegurarnos que
obtenemos el mismo resultado: 10
-'
127
:
137
y
-5
+ 127
:
lll. as
Nuevo exponente
:
137 + 122
:
259
Desplazamiento derecha
Desplazamiento izquierda
o derecha
Aritmtica para computadores 209
Este resultado es muy grande para un campo de exponente de 8 bits,
asi
que
alguna cosa est fuera de lugar! El problema est en el desplazamiento,
porque estamos sumando los desplazamientos asi como los exponentes:
Nuevoexponenre: (10 + 127) + (-5 + I2'l): (5 * 2
x
127):
t59
Normalmente. para obtener la suma correcta desplazada cuando sumamos
nmeros desplazados, debemos restar el desplazamiento de la suma:
Nuevo exponenre
:
l3'7 + 122
-
127
:
259
-
127
:
132
:
(5 + 127)
y 5 es realmente el exponente que calculamos inicialmente.
Paso 2. A continuacin viene la multiolicacin de las mantisas:
1 . I 10,ri.,
9.200ai.,
Paso 3.
Paso 4.
0000
0000
2220
9990
10212000,ri".
Hay tres digitos a la derecha del decimal para cada operando, asi que el punto
decimal se coloca seis dgitos de la derecha en la mantisa del producto:
10.212000.ri.,
Suponiendo que podemos mantener slo tres d,sitos a la derecha del punto
decimal. el producto es 10.212
x
105.
Este producto no est normalizado, as que necesitamos corregirlo. De
nuevo, hay mltiples representaciones de este ntmero. por ello escogemos let
forma normalizada:
10.212di.,
x
10s:1.02 l2,..
x
106
As, despus de
.la
multiplicacin, el producto puede desplazarse a la
derecha un digito para ponerlo en forma normalizada. sumando I al expo-
nente. En este punto podemos comprobar el desbordamiento y el desborda-
miento hacia cero. El desbordamiento hacia cero puede presentarse si am-
bos operandos son pequeos
-es
decir, si ambos tienen exponentes
negativos
-grandes.
Suponemos que la mantisa tiene solamente cuatro dgitos (exclul'endo el
signo). por ello debemos redondear el nmero. El nmero
l'0fll,i'"'
x
106
se redondea a cuatro d-eitos en la mantisa parr obtener
I .01 I
d,".
x
106
210 Organizacin y diseo de computadores
Paso 5. El signo del producto depende de los signos de los operandos originales. Si
son iguales, el signo es positivo;en otro caso es negativo. Por consiguiente, la
suma es
+ 1.021di..
x
106
El signo de la suma en el algoritmo de suma se determinaba por la suma de
las mantisas, pero en la multiplicacin el signo del producto se determina
por los signos de los operandos.
De nuevo otra vez, como muestra la Figura 4.43,Ia multiplicacin de los nmeros
binarios en punto flotante es bastante similar a los pasos que hemos completado. Comen-
zamos calculando el nuevo exponente del producto sumando los exponentes dqsplazados,
asegurndonos de restar un desplazamiento para obtener el resultado adecuado. El paso
siguiente es la multiplicacin de las mantisas. seguido por un paso opcional de normaliza-
cin. El tamao del exponente se comprueba para situaciones de desbordamiento o para
el desbordamiento a cero, y despus se redondea el producto. Si el redondeo nos conduce
a una normalizacin adicional, comprobamos de nuevo el tamao del exponente. Final-
mente, inicializamos el bit de signo a I si los signos de los operandos fuesen distintos
(producto negativo) o a 0 si fuesen iguales
(producto positivo).
EJEMPLO
Tratar de multiplicar los nmeros 0.5", y
-0.43756..
utilizando los pasos de la Figura 4.43.
RESPUESTA
En binario, la tarea es multiplicar 1.000o,
x
2-r por
-
l.llOdo,
x
2-2.
Paso 1. Sumando los exponentes sin desplazamiento:
_t
-
[_])
: _3
o, utilizando la representacin desplazada:
(-1 + 121) + (-2 + 127
-
127
:'(-l
-2)
+ (127 + 127
-
121)
:
-3
+ 127
:
124
Paso 2. Ivlultiplicando las mantisas:
1.000d.,,
l. i 10,r,,,
0000
1000
1000
1000
El producto es l.l10000,,.
1.110d.,,
x
l-3.
I I10000,r.,.
l--. p.ro necesitamos conservarlo en 4 bits. asi que
Ariimtica
para comPutadores
211
1. Sumar los exponentes desplazados de
los dos nmeros, restando el
desolazamento
de la suma
para obtener
'el
nuevo exponente desplazaclo
2. MultPlcar las mantisas
3. Normalizar el producto si es necesario,.
dJiplazndolo
a ld derecha.e incrementando
el exoonente
/Desborda-\
iento o desborda:
xr
5l
Excepcin
4. Redondear la mantisa al nmero
de bits aProPiado
No
Norm izado
S
5. Iniciizar el signo del producto a
oositivo si los signos de los operandos
-oriqinales
coinc-iden. 5i son distintos.
-
hacer el signo negativo
Realizado
Figura 4.43. M ultiplicacin en punto f lotante., El camno normal es ejecutar los pasos 3 y 4 una vez' pero
si el redondeo hace que iu ,rt"'no est normalizada, se debe repetir el paso 3'
212 Organizacin y diseo de computadores
Paso 3. Ahora comprobamos el producto para asesurarnos si est normalizado y despues
comprobamos el exponente para el desbordamiento o desbordamiento hacia cero. El
producto est ya normalizado y, como 177 >
-
3 >
-
126, no hay desbordamiento ni
desbordamiento a cero. (Utilizando la representacin desplazada,255 ) 121 ) 0. as
que coge el exponente.)
Paso 4. Redondeando el producto
no se realizan cambios:
l'110..'
x
l-3
Paso
-'r.
Como los signos de los operandos origrnales difieren, hacer negativo el signo del
producto. Por consiguiente, el producto es
-1.110.r...
x
l-3
Convertir a decimal para comprobar nuestros resultados:
-1.11Odo.
x
l-r:
-0.001110..': -000111,r,,.
:
-7li:i..
:
-7
31.,".
:
-0.11875.ri",
El producto de 0.5", y
-0.4375..
es
-0.)18751",.
Ivf IPS soporta los formatos en simple y doble precisin del IEEE con las siguientes
instrucciones:
t Stuttct en sintple precsin (add. s)
flotante
t Resta en simple precisin (sub. s)
t tr-lultiplicacin en sintple precisin
(mu L . d) en punto flotante.
y stntr.l tloble precisirr (add.d) en punto
t Dit'isin en sintple precsin (div. s)
1
en tloble precisin d'iv.d) en
punto flotante.
:
t Comparacin en smple precisin (c . x. s) y conlparacin en doble precisirt
(c.x,d) en punto flotante, donde x puede ser iguul (eq). no igual(neq),nletrcr
que (L t). tnenor o gual clue (L e). tnaror que (gt), o n'ta\;or o igual
que (ge).
t Salto t'errlatlero (bcLt) y saltoJalso
(bcLf
)en punto flotante. La comparacin
en punto flotante pone un bit a verdadero o falso. dependiendo de la condicin
de comoaracin. v un salto en Dunto llotante entonces decide si saltar o no
saltar. dependiendo de la condicin
Una cuestin a la que los diseadores de computadores se enfrentan, al soportar lir
aritmtica de punto flotante, es si utilizar los mismos registros que las instrucciones
enteras o aadir un conjunto especial para el punto flotante. Como los pro-eramas
normalmente realizan operaciones enteras
t
operaciones en punto flotante sobre
y resta en punto flotante.
(muL.s) v multiplicacin en cloble precisitt
Aritmtica para computadores 213
datos diferentes, separando los registros solamente se incrementar ligeramente e-
nmero de instrucciones necesarias para ejecutar un programa. El malor impacto es
crear un conjunto separado de instrucciones de transferencia de datos para despla-
zar datos entre los registros de punto flotante y memoria. Los diseadores de ivlIPS
decidieron aadir registros separados de punto flotante
-denominados
Sf0, Sil,
Sf2, ...- utilizados bien para simple precisin o para doble precisin.
1''
por consi-
guiente incluidos en car_qas v almacenamientos separados para los registros de punto
flotante en simple y doble precisin: L.s, s.s, L.d y s.d. Por tanto, el cdigo
MIPS para cargar dos nmeros en simple precisin desde memoria. sumarlos y
despus almacenar la suma puede ser como ste:
L. s $f4,x($29)
L.s $6,y($29)
add.s $'f2, $'f 4, $f 6
s, s $f2,2($29)
Carga nmero P. F. de32 bits en F4
Carga nmero P. F. de32 bits en F
F2: F4 + F s'impLe precisin
ALmacena nmero P. F. de32 bits desde
F2
.{+
t4
fl
1+
t+