Aritmetica para Computadoras y Familias PDF

UilIVERSIDAD ilACTO}IAt DE IIIGEIITERIA
Forultod de Ingenierio Elcriro y Electrnico

J,
c /2<u/7os E cTAa /tt cog D/G /74L.9
JCmj.r
Aro /
ZAoerh
4!ft8;
it& tz/zsca<b
/. c/RcatTo o La F/6e//7 Pl UsA <c/'t?Q a74t A/A^/b bF
t.,
-Lo'alc
AL.a/nARAOA'/. Es<e/B/ a T&a o v&D P.&p L,a
z7-//?m
P'Qdgt-rA /.
-
Paza R<pr24
F/eeeeoro
,S'LtfqS;
CaL<7a4- .4A/'270
-salL F dc s4L/A
CltQ c,/t'70 ,
l,
^
er,oPtciJ
zd6t4 raca F <.o u*' Fu,v<'rs/
+ 54V
o L.s apleaatls, c/./
u<.
tlt)t2ttt
71/.Sot
?RcA
-2.-
(oau'.<
{. h Fan'/<a
77L
74 Ls al
F a .iA
Dscppc l s/
m 6./ 7+ 74
71H 7+3 74S
74A3 74A/S
'7iaa/o
/e
y'r27"crt
rhi,zto GtS)
CanS* dt fotnn.,
fa^
Cenk"{n
(nW)
Pa"&-oh c{z Valanc.t.t - Velec,sl2/
(f)
Vo({zc /o e"tad /e
nve/ ac
(v)
,/ot.fz-o
& sul/^
"
o.."./ eaw
(v)
Vaf"?e #4^'/. c arv{ zzra
(v)
{.I/-f 9,'.. ,n"r{ aaro ( v)
Cour,vt e erl^J"
& r,u'*/
earo (,ma)
(Ln^"ntd.
Jo/,'
"4
,*'t+/
8"t7o C/0)
tort, "[ al orr/rJ.,y't ..rr"/
a.rc (),a)
Cc*.'r*bd,
.Pa/"L/:
,xve/ atro (ua)
t
^"*.
YcL
waY,
urq
'rrn-.
VOI+
,r*''t.
ZaL
,r,-^'
Jc
rax.
ZsH
^.t.
Jo^
*,
/.6
5
20 /,3
32 6.5
0.8 0.6
o,5
d'5
2- o 2,o
2.7 2-7
-
z.c
-o-z
2a6
zcc
zo
-
zcoo
-toc
7
t0
2o
0.6
,1
2-0
2.4
_
t.6
/6
4
-1o
3J
J
33
d.7
c-q
2.a
2,1
-c./6
3-6
l0
-zo
6
z2
/32
u,'
0.q
2.O
2*+
-2.
za
5ci-
-&o
3
2
6o
O,E
c.5
2-a
z-7
-2-o
zo
^-
-
lccc
I
2
/6
d-8
0's
2.C
2-7
-4/4
d
2c
-./cv
tc:
+sv
-:ra
y'z.
r{,
fipr
3
82v 7a,Rt'A
7./.- t/R..u/ ros
& c./e<-ar
A'tfb
v.a='"v
Fl;upA z.
-
rr /e Gltot:, lkJi
faTcn Pc 77L
T.xrart.n\
unc- a/u../n utro,
J-]*
?e
"l
vol,{V d' ;A
h*T'Vc<
^
ton'h*.,*
/
8o ALT7
.
EstTaa.rn, lt^ g
-'tr'6
ut' {oo
C.mFtolao c^
pJ/a
"4
c"t h .hr./ C,4a P
/tt+uztrtc.
'n L
Fi:tor.-
2 ,
J-
?4J::4s||i,f*iziil/||'.-m"@nlr/nôy7a"*n.,ao;*--!:7a,',l'-:Laz"1aJn,
cry.
,,t/,!1'
la evaipinf*t
,,
O a.
4,
J,
-p7t
.:
h)', 4tnax ; :
/^
?;
',
n1y1ta j*: -
,niA ,,
to-:
/::lil*r
? .
F/6u.a 3.- lEb
Ailt'74
b ,v UtlA
6aL/ bG CoLacTV?
F4rATo.
Var='/
SV
Lab pt "o.t
./"
2 aAA -t q
.-
^/
t
P44:
p*p)..*o- ',+nt, J,
v/4
8A7o
ft+; a7a,r.4
'.^,
,rlV
Wn )+'o
t'y4
' .,VoLwax
,, f
it4t
o7$'g.'ui von
V9.'b*;,
/a eo,,--ub
fq
h?o
Qvin-*nn./4/tr.
(*)
Yotrn*,
/ lUV
rtze\,vso
lut
u'>tz
f4,
4 / Q#.J- 8.za/
Saa^.tg^ oo&,a..n
( .*'o,|a/at
.)"4 e
f
<rctJn Zoanr)..
.
De ln fteu z.-' b"'4
^
,u1
\tn"u tAt' L',o.'./^
r&oata(
roro 4l^&.u.ro
--
*,,nrhynza&.'
(yff.,^? 4
o/rr*,8.r'
o-rn) ,^" la gr/rra,rA
a&-.r^h.
tu err*or,-,r'*rr-
, "1n,
tlonooor*, ,
.a.a| d ?nao o a/
p* rn
e.r'.
/ma-
/a conr/'rj*
"O.*
--&.z
)^ /o".^
k" e.nV-tlfa.a c'n'ro, l^^,r'.rtfâ
t$rr. ,4d'5,'t
d' Pu.
)*'
q^ p/* d., lt t
oL,
f Poas",t
vn
o zn l
,+rt4/L+p l,yt
{ca<t'crzd
:
/aro
'ol'*n/-
/'u& t<'sz.zc d
o'z gbo"l
tLe/t2
Z
a{nr
&;^- bq,,
' L br,zr
J
/*ro
1u.Jg*t
Lg"^ a/.,'lnoft.
(/,n"
po/
I
c"kh, a&" pu/t al'*r^/*'^ uu /E
(an*pt,',,ru#n
e't
y't
f
5ttr,.3.
5.' a.*/.*'rt- 1* ,'rlno-Lt
X
"
/ EazA
,
lo* aS
"
e:*t
X
,/
"ttLa,n
.4L7o.
p a<ta,el.
o..h,^

- il v.Jn &
1^
rt-,r.*.:
u
P"ru //ua n Vc
e
J+,
fata )ott #g^
1^ c*,.^tr/'"/
qnya/^
"t
a',u...'i
^
{nor-i
d
je"
n, / u#.
u
s6
-
,Pon W e
.J Lb A)*z /o,*aA
/.eo
btUo.,Q
.n*rJ
J
th uno ea-.'/n d /, C V,
cAg.aor
08v*
Stz
k*,
trt
""
u,^
7J'o4
uzf* /
Qt 4h oLu,
Vrr."*
=
o.4v
,
/o
ryo'/.e^z"
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./ôtor'.
-"*'r*,1;,1.'o"l
F
*- n^
!tf'F"
,l*
f4Vt^
/
,+?^
,nJ*uJ
rL
.,/"., t.* ,L
/n
P^/r..l
yr/.*3./^
u- inctô*
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ô"-*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-
/â
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
,
,ô
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â.-"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 /-
*{î';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. {- &lt"- ctQ
7ma/,r.zczz,n
/'a
etlotc^
,ô;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î
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'ô
*.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ô-,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"ô^
=
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* & /-
ô
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",
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.
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
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.
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
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",
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
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.
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
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
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.
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
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
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
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).
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
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
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
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
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.
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
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'
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
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
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
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.,.:
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",
=
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.
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
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
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
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.
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
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
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.
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.
'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
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
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
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
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'.
programacin sera an ms dificii.

-
Calculamos las dems combinaciones siguiendo la misma lgica:
+7 +
-2:
Cociente:
-3,
Resto:
-r1
-7
+
-2:
Cociente
:
*3, Resto
:
-1
Observar que un resto distinto de cero siempre tiene el mismo signo que el dividendo.
As el algoritmo de la divisin con signo hace correctamente que el signo del resto sea igual
que el del dividendo.
1'
el cociente es negado si los signos de los operandos son opLlestos.
El lector observador reconocer que para mr-rltiplicar y dividir se puede utilizar el
mismo hardivare. El nico requerimiento es un registro de 64 bits que puedit
desplazar a la izquierda o a la derecha y una ALU de 32 bits qrle sume o reste. Por
ejemplo, IUIPS utiliza los registros Hi de 32 bits y Lo de 32 bits para multiplicar y'
dividir. Como podriamos esperar del algoritmo anterior, Hi contiene el resto y Lo
contiene el cociente despus de la instruccin de dividir. Para manejar tanto enteros
con signo como sin signo. \IIPS tiene dos instrucciones: diridir (d'iv) y dirid' sitt
slgno (divu). El ensamblador ivlIPS permite que las instrucciones de divisin especi-
fiquen tres registros. facilitando las instucciones mfLo y mfhi para colocar los
resultados en registros.
Las instrucciones de divisin de MIPS ignoran el desbordamiento. as el softrvare
debe determinar si el cociente es mlly grande. Adems del desbordamiento, la
divisin tambin puede producir un ciculo impropio: la divisin por 0. Al-eunas
mquinas distinguen estos dos eventos anmalos. El softrvare de lvllPS debe com-
probar el divisor para descubrir la divisin por 0 as como el desbordamiento.
Resumen
.
El hardrvare que normalmente soporta la multiplicacin y divisin permite que NIIPS
proporcione un par de registros de 32 bits que se utilizan para multiplicar
l
dividir. La
Figura 4.40 resume las adiciones a la arquitectura MIPS en las dos ltimas secciones.
Elaboracin: La razn por la que se necesita una iteracin extra para el primer algoritmo y el
desplazamiento anticipado del segundo y tercer algoritmos involucra la ubicacin del dividendo
en el registro Resto. Esperamos tener un cociente de 32 bits y un divisor de 32 bits, pero cada
uno realmente es un entero de 31 bits ms un bit de signo. El producto sera 31 + 31, o 62 bits
ms un bit de signo; el hardware puede entonces soportar solamente un dividendo de 63 bits.
Dado que los registros normalmente son potencias de 2, esto significa
que debemos colocar
adecuadamente el dividendo de 63 bits en el registro Resto de 64 bits. Si colocamos los 63 bits a
la derecha, necesitamos ejecutar el algoritmo un paso extra para obtener ese ltimo bit. Una
solucin mejor es desplazar antes. ahorrando asi un paso del algoritmo.
Figura 4.40. Arquitectura MIPS revelada hasta ahora. La negrita indica las partes reveladas desde la
Figura 4,6 de la pgina 161. El lenguaje mquina MIPS se ilustra en la pgina xxxiii de este libro.
Operandc MIPS
Nombe Eiomplo Comentarios
32 regstros )u, )t, Jz, ..., |
H, Lo
Posicones rpidas pra datos- En MIPS los datos deben estar en registros para
realizar la aritmti. El regislro S0 de MIPS siempre es gual a 0. El regstro S1 se
reserya para que el ensamblador maneje las pseudoinstrucciones y grandes cons-
tantes. Hi.y Lo son registros de 32 bhs que contenn el resultado de la muhipli-
cacron y orvlsron,
t'o palabras
de memoria
Memoria[0],
Memoria[41,...,
M emoria[ 4294967292 ]
Accedidas slo por nstrucciones de transferenca de datos. MIPS utiliza slo
direcciones de bytes, asi las palabras secuenciales difieren en 4. La memoria
contiene estructuras de datos, tales como arrays, y regstros derramados, como
los salvados en las llamadas a los grocedimentos
Lenguaje ensmblador MIPS
Categora lnstrucn Ejmplo Sgncado Comentarios
Aritmtica
sumar add 51,S2,S3 )t=)z-x 3 operandos; excepcin posble
restar sub 51,S2,S3 3 operandos; excepcn posble
sumar inmedato addi S1,S2,100 51=S2-100 + constante; excepcin posible
sumar stn stgno addu S1.S2,S3 S1=32-33 3 operandos; no excepciones
restar sn signo subu 31,S2,S3 51=32-S3 3 operandos; no excepciones
smar inmediato sn sgno addiu S1,S2,100 S1=S?-100 constante; no exceociones
transf. reg. cop. NO mfco St,Sepc 51 = Spc Usado para conseguir excep. PC
multiplicacin mult S2.S3 Hi. Lo=32r53 prod. con sgno de E4 bts en H, Lo
muhiplicacin sin signo muttu 52,43 Hi, Lo = 52
.33 prod. sin sgno de 64 bits en Hi, Lo
divisin div S2,S3 Lo:52 33. Hi=52 mod 33 Lo = cociente, H = resto
dvisn sn signo divu 32,18 Lo = S2 33. Hi = S2 mod 53 cociente y res. sin signo
Transferir de Hi mfhi 51 51 =Hi usado para obtener copia de Hi
fransferir de Lo mflo 31S 31=Lo u*do para obtener copia de Lo
Logicas
ano and 51.S2.S3 sr =s2 & s3 operandos 3reg; AND lgica
or
n (r e? (?
>r=5zu operandos 3reg; OR lgica
and nmediato and S1.52,100 S1 =S2&100 AND lgica ANO reg. constante
or nmedato or S1 .52.1 00 OB lgica reg. constante
desplaz. logico zda. sll S1,S2,10 S'l = 52 << 10 Desplaz. izquierda por constante
desplaz. lgico dcha. srl S1.S2.10 51=52>>10 Oesolaz. derecha oor constante
Tra nsfe-
renca
de datos
cargar paraora s 1.1 00(s2) S1
:
lemoriai52.lC0l Dato de memora a regstro
almacenar palabra sw 51.100(52) Memoria(52+ 1001=S1 Dato de registro a memora
cargar inmedato sup. lui S1.100
g1=100.2'5
Cargar ctes. en
'16
bits superiores
Sato
coodicional
saltar sobre igual beq 51,S2,100 s isl
==S2) ir a PC-4- 100 Test igualdad; salto rela. PC
saltar sobre no igual one >r,52, ruuu si
(S1 !=S2) ir a PC - 4
- 100 Test no igualdad; salto rela. PC
inic. sobre menor que slt S1.52.53 s lS2<S3)S1 = 1; si no 51 =0 Compara menor que; comp. a 2
inic. sobre menor que inm, slti S1,52,100 si lS2 < 100)51 = l; sr no 51 =0 compara < cte.; comp. a 2
rnrc. menof que sln 5l9no sltu S1,S2.!i:l si {S2<33) Sl =1; si no 31 =0 Comoara menor oue; no natural
inic. menor que inm.
sin signo
sltiu S1.S2,100 s
(S2 < 100)Sl
:1;
si no 31 = 0 Compara < cte., natural
Bifurcacin
bfu rca r
j 10000 r a 10000 Eifurca a dreccin destino
bf. regstro ir a S3'1 Para cambiar; vuelta de Droced.
bif. y enlazar
jal 10000 S31 =
PC
-
l; ir a 10000 Para llamada a orocedmiento
4.8. Punto flotante
l,a telocidad no llera a nngton parte s no se Da en Ia direccin correcta.
Proverbio americano
Adems de los enteros con signo y sin signo, los lenguajes de programacin incluyen
nmeros que representan nmeros fraccionarios,
que en matemticas se denominan reales.
Aqu hay al-eunos ejemplos de reales:
3.14159265
-'.ai., (pi)
2.71828 "
0i".
()
0.000000001,ji.. o 1.00l".
x
l0-e (segundos en un nanosegundo)
3.155.760.000di.. o 3.155760,".
x
l0e (segundos en un siglo)
Observar que en el 1timo caso. el nmero no representa una pequea fraccin. pero es
mayor de 1o que podemos representar con un entero con sisno. La notacin alternativa
para ios dos itimos nmeros se denomina notacin cientJica. que tiene un solo dgito a la
izquierda del punto decimal. Un nmero en notacin cientca que no vaya precedido
poi 0
lceros)
se denomina nmero normalizado, que es la forma habitual de escribirlo. Por
...pio, 1..,".
r
10-e est en notacin cientca normalizada. pero 0.1i.,
x
10-t y
10.0.,
x
10-10 no lo estn.
O tu misma forma como podemos mostrar los nmeros decimales en notacin
cientiflca, tambin podemos mostrar nmeros binarios en notacin cientca:
1'0oo'
x
2-t
La base binaria sustituye a la base decimai para que podamos ajustar el exponente en I
pa:a mantener el nmero binario en forma normalizada.
La aritmtica de computadores que soporta estos nmeros se denomina pno
flotante.
porque representa nmeros en ios cuales el punto decimal no est fijado, como ocurre en
ios enreros. El lenguaje de programacin C utiliza el nombre
float \flotante)
para estos
nmeros. Igual queennoracin centfica,los nmeros se representan con un solo dsito a
la izquierda del punto decimal. En binario, la forma'es
1.,r,t,t.t'x-r-r-x-\,r.',
X
2't'tl't
(Aunque
el computador representa el exponente en base 2 asi como el resto del nmero.
para simplificar la notacin mostraremos el exponente en decimal')
Una notacin cientiflca estndar para los reales en forma normalizada ofrece tres
ventajas. Simplilica el intercambio de datos que incluye nmeros en pLrnto flotante;
simplihca los ilgoritmos de aritmtica en punto flotante al saber que los nmeros estarn
siempre en estt forma: e incrementa la precisin de los nmeros que pueden almacenarsc
.n ur, palabra. ya que los 0
(ceros) precedentes innecesarios son sustituidos por nmertls
reales a la derecha del
puntc-r
decimil.
El diseador de la aritmtica debe encontrar un compromiso entre el tamao de la
mantisr y el tamao del exponente, porque un tamao fijo de palabra signihca que se debe
tomar un bit de un campo para aadirlo ai otro. Este compromiso est entre precisin y
rango: Incrementar el tamao de la mantisa enriquece el nmero de bits para representar
la mantisa, pero incrementar el tamao dei exponente incrementa ei rango de nrmeros
que pueden representarse. Como nos recueida nuestro principio guia del Captuio 3, un
buen diseo demanda compromiso.
Estos tamaos escogidos de exponente v mantisa dan a la aritmtica dei computador
lvf IPS un rango extraordinario. Fracciones tan pequgas como
?.0.. x
10-38 y nmeros
tan
-srandes
como 2.0",
x
1038 pueden representarse en el computador. Esto diliere
ertraordinariamente del infinito. va que todar'a son posibles nmeros mucho mayores.
Por tanto, en ia aritmtica de punto flotante se puede presentar interrupciones de desbor-
damiento i,eual que en la aritmtica entera. Obserrar que aqu tlesbordantiento
(ouerJlo*')
significa qLre el exponente es mu)'
grande
para que sea representado en el campo de
exponente.
El pr.rnto flotante ofrece tambien un nuevo tipo de evento excepcional. Igual que a los
pro*eramadores les gusta saber cundo han calculado un nirmero muy grande para que
pueda representarse, les gustar saber si la fraccin que estn calculando ha sido tan
pequea qLle no puede representarse: o bien cualquier evento puede producirse en un
programa dando respuestas incorrectas. Esta situacin se presenta cuando el exponente
nesativo es tan grande que coge en el campo dei exponente. Para contrastar esta sitr-racin
con el desbordamiento
\oL'erJIe11,).
algunos personas denominan a este evento desborda-
nriento a cero lwtderllow).
El espritu prctico indica que los nmeros en punto flotante son compatibles con el
tamao de palabra. La representacin de un nmero en punto flotante en MIPS se
muestra ms abajo, donde s es el si-eno del nmero en punto flotante (1 significa
negativo), exponente es el valor de un campo erponente de 8 bits (incluyendo el si_sno
del exponente)y mantsf es un nmero fraccionario de 23 bits. Esta representacin se
denomina en si.cno
y,
nngnitud, ya que el signo tiene un bit separado del resto del
nmero.
31 29 28t21 zo 25t24 22 21 z0
'I
17 tot t5
1A 1? 1
11 1 9 817 o 5 3 2 1 0
exponenle mantsa
En general, los
23 bits
nmeros en punto flotante son de la forma:
F involucra el valor del
la relacin exacta entre
(-1)s x
F
x
2E
campo mantisa y E involucra el valor del
estos campos se expiicar pronto.
campo exponente;
Para reducir las posibilidades de desbordamiento a cero o desbordamiento, la mayor
parte de los lenguajes de programacin ofrecen una notacin que tiene un exponente
mayor. En C se denomina double (doble), y las operaciones sobre dobles se denominan
aritmtica en punto fiotante de doble precisin; punto flotante en smple precisin es el
nombre del formato anterior. La doble precisin de MIPS permite nmeros tan pequeos
como 2.00'.,
x
10-308 v casi tan
-qrandes
como 2.00". x
1030s.
Estos formatos van ms all de MIPS. Forman parte del estndar de puntoflotante del
IEEE 754, que se encuentra virtualmente en cada computador inventado desde 1980. Este
estndar ha mejorado enorrnemente la facilidad de portar pro,sramas de punto flotante y-
la calidad de la aritmtica de los computadores.
Para empaquetar an ms bits en la mantisa, IEEE 754 hace implicito el valor I para
el primer bit de los nmeros binarios normalizados. Por consiguiente, la mantisa tiene
realmente 24 bits en simple precisin (1 implicado y una fraccin de 23 bits). y 53 bits en
doble precisin (1 + 52). Como 0 no va precedido a ningn 1, se da el valor de exponente
reservado 0 para que ei hardlare no considere el primer 1. Por tanto.00...00do,
representa 0: la representacin de fos restantes nmeros utiliza la forma anterior con el 1
oculto aadido:
(-l)s*(1 *mantisa) x2r
donde los bits de la mantisa representan la fraccin entre 0 y 1 y' E especifica el r'rlor del
campo exponente. que se detallar en breve. Si queremos nunlerar los bits de la mantisa
de izcluierda a derec'ltct sl. s2. s3.
..'
. entonces el valor es
(-l)t x (1 + (s1 x
l-t) + (s2 x
2-2) * (s3 x
2-3) + (s4 x
2-+) *'.') *
2t
Los diseadores del IEEE 754 tambin queran una representacin en pLlnto flotrnte
que fuese fcilmente procesada por operaciones enteras. Esto es porque el signo que es el
La representacin de un nmero en punto flotante y doble precisin necesita dos
palabras ivllPs. como se muestra ms adelante, donde s es todava el si_eno del
nitmero. exponete es el valor del campo exponente del I I bits y llrrlri.ta es el
nmero fraccionario de 52 bits.
1 30 29 28 at 25 2423
..1. ,
..11 | 20 19 1 1l t 14 1 12
1a
II 10 9 7 6
6
ls Z 1 0
exponente mantrsa
1 bit
't
1 bits
mantisa
(conto)
32 bits
bit ms significativo, permite que se realice rpidamente un test sobre menor, mayor, o
igual que 0. Colocando el exponente antes de la mantisa simplihca la ordenacin de
nmeros enteros en punto flotante, ya que los nmeros con mayores exponentes parecen
mayores que los nmeros con menores exponentes, mientras tengan el mismo signo.
Los exponentes negativos suponen una dificultad a la ordenacin simplicada. Si
utilizamos complemento a dos o cualquier otra notacin en la cual los exponentes
negativos tengan un I en el bit ms significativo del campo exponente, un exponente
negativo parecer un nmero grande. Por ejemplo, 1.0o,
x
2-L se representar como
(Recordar que el primer I est implcito en la mantisa.) El valor 1.00o,
x
2*t ser el
nmero binario ms pequeo:
La notacin deseable debe adems representar el exponente ms negativo como
00...00do, y el ms positivo como 11
...
11oo,.A esto se denomina notacin polarizada
(desplazada), siendo el desplazamiento (bias) el nmero restado de la representacin
normal sin signo para determinar el valor real.
IEEE 754 utiliza un desplazamiento de 121 para simple precisin, as
-
1 se representa
porel patrndebitsdevalor
-l+I27di,,o
1260,.,:0111 1110do,,y *1se representapor
l+I27 128,ii.,
:
1000 0000.",. Esto significa que el valor representado por un nmero
en punto flotante realmente es
(- 1)t
x (1 + mantiSa)
X
,7iexponente-dcsplazumicnto,
El desplazamiento del exponente para simple precisin es 121 y para doble precisin
es 1023.
EJEMPLO
N{ostrar la representacin binaria del IEE 75"1 de los nmeros
-0.75di",
en simple
1'
doble
orecisicin.
RESPUESTA
El nmero
-
0.75,", es tambin
-
i..'4,.. o
-
3 2,".. Tambin se
-
llu,2tu'., o
-0.
11,r,,,. En notacin cientca el lalor es
-0.
11u.,,
x
nnrm:rlizrd:r es
-ll
x
1-l
^
.J\
L;.r representacin general para simple precisin es
(-l)s x (l r mantisa)
x
lreponcnrc
1:-r
rcprcsent.r por la ireccin
2o v en notacin cientifica
JI 30 28 27 26 25 24 23 z1 20 19 18 17 to tc 14 IJ 12 11 10
q
I 7 o 5 2 I 0
0 11111111 00000000000000000000
JI 30 29 z 21 zo a 24 3 22 z1 20
't9
18 17 t5
1A
13
1t
11 10 9 8 7
A
2 0
0 00000001 00000000000000000000
y por ello este nmero es
(- l)'
La representacin binaria
x (l +.1000 0000 0000 0000 0000 000..,)
x
2(126)
en simple precisin de
-
0.75"' es entonces
1 bt 8 bits
La representacin en
23 bits
doble precisin es
(
-
1)'' (1 +.1000000000000000000000000000
000000000000000000000000o.)
x
2(to22t
ZU
3'l 30 29 28 27 o 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10
o
8 7 o 5 4 3 2 1 0
1 0 1 1 1 1 1 I Oll O o o 0 o 0 o o o o 0 o o o o o o o o o o o
31 30 29 28 27 E 25 24 ZJ 221121 20 19 t8 17 to 14 13 tz 11 10 9 7
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
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:
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.
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
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
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'
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
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+
La Figura 4.40 resume la parte de punto flotante de la arquitectura ivllPS revelada en

el Captulo 4, las adiciones que soportan el punto flotante aparecen en negrita.
Elaboracin: Slo 16 de los 32 registros de MIPS en punto flotante pueden ser utilizados para
operaciones de simple precisin:
SfO, $f2, $f4, ..., $f30.
La doble precisin se calcula utilizando
parejas de estos registros. Los registros de punto flotante de numeracin impar se utilizan
solamente para cargar y almacenar la mitad derecha de los nmeros de 64 bits en punto
flotante.
Precisin aritmtica
De forma distinta a los enteros. que pueden representar exactamente cada nmero entre el
ms pequeo y el ms grande. los nmeros en punto flotante son normalmente aprorima-
ciones a un nmero que no pueden representar realmente. La razn es qqe eriste una
variedad innita de nmeros reales entre, digamos,0 y'1. pero no ms de 153 pueden ser
representados exactamente en punto flotante en doble precisin. Lo mejor que podemos
hacer es obtener la representacin en punto flotante prxima al nmero actual. As. el
LEEE754 ofrece algunos modos de redondear para permitir al programador que escoja la
aproximacin deseada.
Redondear suena bastanre simple, pero redondear con precisin requiere que el hard-
r,vare
incluya bits extra en el clculo. En los ejemplos precedentes estbamos indecisos
sobre el nrmero de bits que una representacin intermedia poda ocupar. pero claramente
si cada resultado intermedio ha de truncarse al nmero exacto de dgitos. no habrt
oportunidad de redondear..\dems. IEEE 754 siempre conserva I bits ertra a la derecha
durante los clculos intermedios. denominados de guarda y redontleo, respectivaniente.
Hagamos un ejemplo decimel para ilustrar el valor de estos dgitos ertra.
Figura 4.44. Arquitectura MIPS en punto flotante aparecida hasta ahora. Vase el Apndice A.
Seccin A.10, para ms detalles.
Operandos MIPS m punto flotante
Nombra
.Eiemplo
Comsntrios
32 registos
en punto
flotante
sfo, $f1, sf2, ..., $31 Los regilros de pontero flotante de MIPS se utilzan en parejas para nmeros en
doble precisin. Los reglros con numeracin impar no pueden utlzars para
aritmtica ni para sahos, sino para transfrencia de datos de la (mtad,
derecha
de los registros peres de doble pr*isin.
t'o palabras
de memora
Memoria{01,
Memoria{41, ...,
Memoria{4294967292 I
Acceddas slo por nstruccones de transferencia de datos. MIPS utiliza slo
direccones de bvies, as las oalabras secuenciales difieren en 4. La memora
contene estructuras de datos, tales como arrays, y regstros derramados. como
los salvados en las lamadas a los orocedimentos
Lenguaje ensamblador MIPS en punto flotante
Categora lnstruccn Ejemplo Signicado Comantaros
Aritmtica
suma FP simple precisin add.s Sf2,Slf,Sf6 Sl2=Sf4 -
Sfo Suma punto flotante {smple prec.)
resta FP simple precisin sub.s Sl2.Sf4,3fo Sf2:5f4
-
Sf6 Resta punto flotante (simple prec.)
multiplcacin FP s. prec. mul.s Sfz,Sf4,9f6 Sf2=Sf/t
^
Sf6 Multiplica. punto flotanle (s. prec.)
divisin FP smple precisn div.s Sf2.Sf4,Sf6 Sf2=Sf4 Sf6 Divisin punto flotante (s. prec.)
suma FP doble precisin add.d Sf2,Sl4,SfG Sl2=Sl4
-
Sf6 Suma punto flotante (doble prec.)
resta FP doble precisin sub.d Sf2,Sf4,Sf6 sf2=sl4 - sf6 Resta punto flotante (doble prec.)
multiplicacin FP d. prec. mul.d Sf2,Sf4,Sf6 Sf2=Sf4
"
Sfo Multiplica. punto tlotante {d. prec.)
divisin FP doble orecisin div.d Sf2.Sf4.Sf6 Sf2:sf4 Sf6 Divisin punto flotante (d. prec.)
Transf+
rencia
de datos
carga palabra copr.1 lwcl Sf1,100(52) Sf 1=Memoriaf 52
-
1001 Dato de 32 bts a regstro FP
almacena palabra copr. 1 swcl Sfl.100{S2l Memoria[Sz -'100]= Sf1 Dato de 32 bits a memoria
Salto
condicional
salta sobr verdad FP bclr 1 00 si
(cond-1)
r a PC'-4-100 Salto relativo PC si FP cond
salta sobre falso FP bclf 100 si {cond==O) ir a PC-4*100 Salto relativo PC si no cond.
Comp. FP simple precisin
(eq,ne,lt,le,gt,ge)
c.lt.s Sf2,Sf4 s (Sf2 < Sf4)
cond=l; si no cond=O
Compara menor que punto tlotante
simple precisin
Comp. FP doble precsn
{eq,ne,lt,le,gt,9e)
c.lt.d Sf2,Sf4 s lSfz < Sf4l
cond=l; si no cond=0
Compara menor que punto flotante
doble precisin
Lenguaie mquina MIPS en punto flotante
Nombre Formato Elemplo Comentaros
add.s R 17 to 6 2 0 add.s sf2.Sl4.sf6
suo.5 R 17 to o 4 2 sub.s Sf2,sf4,Sf6
m ul.s R 17 to 6 4 mul.s Sf2.Sf4,Sf6
div. s R 17 6 2 div.s Sf2.Sf4.Sf6
add.d R 17 17 6 2 0 add.d Sf2.Sf4.Sf6
sub.d R 17 17 6 2 sub.d Sl2,Sf4,Sf6
mul.d R 11 17 6 4 2 mul.d Sf2.Sl4.Sf6
div.d R 17 1'l 6 2 div.d Sf2,Sfa,Sf6
lwcl 49 100 lwcl Sf1,100{52}
swcl I 100 swcl Sf1,100{S2l
bclt I 17 100 bclt 100
bc1 f 17 8 u 100 bclf 100
c. t. s R 17 to 4 0 60 c.lt.s Sf2, Sf4
c.lt. d R 17 17 4 2 0 c.lt.d Sfz, Sf4
Tamao de campo 6 D ITS 5 bits 5bits ; 5bits 5 bits 6 bits Todas las instrucciones
MlPS de 32 bits
EJEMPLO
Sumar
2.561",
x
l0o a 2.31d.o
x
102 suponiendo que tenemos tres dgitos decimales significativos.
Redondear al nmero decimal ms prximo con tres digitos decimales significativos. primero con
los digitos de guarda y redondeo y despus sin ellos.
FESPUESTA
Primero debemos desplazar el nmero ms pequeo a la derecha para alinear los exponentes, as
2.56di",
x
10o llega a ser 0.02,i6..
x
102. Como tenemos dgitos de guarda y de redondeo, podemos
representar los dos digitos menos signihcativos cuando alineamos los exponentes. El digito de
guarda fue 5 y el de redondeo 6. La suma es
2.3400di,,
0.0256di",
) ?6\6,
Asi la suma es 2.3656..
x
l0:. Como tenemos dos digitos para redondear, queremos lalores de 0 a
49 para redondear hacia abajo y de 5l a 99 para redondear hacia arriba, siendo 50 el punto de
ruptura. Redondear la suma hacia arriba con tres digitos signilicativos da 2.370,..
x
l0:.
Haciendo esto sir deitos de
guarda y
redondeo se tienen dos deitos de los clculos. La nueva
suma es entonces
2.34di".
0.02a.,
2.36;",
La respuesta es 2.36
x
l0:. diferencindose en I en el ltimo dgito de la suma obtenida anterior-
mente.
Como el peor caso para redondear debe presentarse cuando el nmero real est a mitad de
camino entre las dos representaciones en punto flotante, la precisin en punto flotante normalmente
se mide en trminos del nmero de bits de error en los bits menos significativos de la mantisa; la
medida se denomina nmero de unidades en Ia ltima posicin o u/p. Si un nmero se diferencia en
2 eh los bits menos significarivos, se denominara con una diferencia de 2 ulps. IEEE 754 garantiza
que el computador utiliza el nmero que est en medio ulp.
Resumen
El gran cuadro si,suiente refuerza el concepto de programa almacenado del Captulo 3; el
signilicado de la informacin no puede determinarse examinando los bits. ya que los
mismos bits pueden representar diversidad de objetos. Esta seccin muestra que la aritm-
tica del computador es finita y por tanto puede estar de desacuerdo con la aritmtica
natural. Por ejemplo. la representacin del estndar del IEEE 754 en coma flotante
(-115x(1*mantisa)x2{elPonentc-dcsplzf,nlenlo)
es casi siempre una aproximacin del nmero real. Los sistemas de computadores y
programadores a veces deben tener cuidado al minimizar este salto entre la aritmtica del
computador y la aritmtica en el mundo real.
Elaboracin: El estndar de punto flotante del IEEE 754 da pocas indicaciones que ayuden al
programador a mantener la precisin, igual que los conmutadores de la carlinga de un avin.
Trataremos algunas aqu, pero examinar las referencias al final de la Seccin 4.11 para aprender
ms.
Hay cuatro modos de redondeo: redondeo siempre hacia arriba (hacia +), redondeo siempre
hacia abajo (hacia
-),
truncamiento, y redondeo al par ms prximo. El modo final determina
qu
hacer si el nmero est exactamente en el punto medio. El Internal Revenue Service
siempre redondea 0,50 dlares hacia arriba. posiblemente para beneficio del lRS. Una forma
ms equitativa sera redondear en este caso hacia arriba la mitad del tiempo y hacia abajo la otra
mitad. IEEE 754 dice que si el bit a la izquierda del caso del medio es impar, aadir un 1; si es
par, truncar. Este mtodo siempre crea un 0 en el bt menos significativo.
Dos dgitos extra siempre son suficientes para los tres primeros modos de redondeo. Obtener
siempre el redondeo a la derecha para el ltimo caso, el estndar tiene un tercer bit adems de
los de guarda y redondeo; se pone a
'1
siempre que haya bits distintos de cero a la derecha
del bit de redondeo. Este bit retenedor (sticky) permite al computador ver la diferencia entre
0,50... 000,". y 0,50...010,". cuando se redondea. El bit retenedor puede ponerse a 1, por
ejemplo, durante la suma, cuando el nmero ms pequeo es desplazado a la derecha.
Otras caractersticas del IEEE 754 son smbolos especiales para representdr eventos inusua-
les. Por ejemplo, en lugar de interrumpir una divisrn por 0, se puede poner el resultado en un
patrn de bits representando + o
-;
el exponente mayor se reserva para estos smbolos
especiales. Cuando el programador imprime los resultados, el programa imprimir un smbolo
infinito. Incluso tiene un smbolo para el resultado de operaciones invlidas, tales como 0/0 o
restar infinito de infinito. Este smbolo es NaN. que significa Not A Number (No Un Nmero).
Finalmente, en un intento de congelar cada ltimo bit de preclsin de una operacin de punto
flotante, el estndar permite que algunos nmeros se representen en forma no normalizada. En
lugar de establecer una barrera entre 0 y el nmero ms pequeo normalizado, IEEE permite
nmeros denormalizados. Tienen el mismo exponente que el cero pero una mantisa distinta de
cero. Permiten que un nmero se degrade en mantisa hasta que se convierta en 0, denominn-
dose desbordamiento a 0 gradual (gradual underllow).
Aqu damos tres codificaciones de nmeros en punto flotante del IEEE 754:
Los patrones de bit no tienen signihcado inherente. Pueden representar nmeros
enteros con signo, nmeros enteros sin signo, nmeros en punto flotante, instruccio-
nes, etc. Lo que se represente depende de la instruccin que opera sobre los bits de la
palabra.
La diferencia principal entre los nmeros del computador y los nmeros del
mundo real es que los nrmeros de aqul tienen tamao limitado, por consiguiente
precisin limitada: es posible calcular un nmero muy grande o muy pequeo para
que est representado en una palabra. Los programadores deben recordar estos
lmites y escribir los programas de acuerdo con ellos.
Simple precisin Doble precisin Objeto representado
Exponente Mantisa Exponente Mantisa
0 0 0
n
0 0 U 0 Dernormalizado
1 a254 Cualquiera 1 a 2046 Cualquiera Nmero en ounto flotante
255 0 2047 U lnf in ito
255 U 2047 NaN
(No
un Nmero)
La posibilidad de un operando ocasionalmente no normalizado ha dado quebraderos de
cabeza a los diseadores de
punto flotante que han tratado de construir unidades rpidas de
punto flotante. Por consiguiente, muchos computadores
producen una excepcin si un operando
es desnormalizado,
permitiendo que el software complete la operacin.
4.9. Falacias y pifias
As /as matetnticas puecle tleJin'se conlo la nnteria tle la t'ual nurca sabemos tle tltL
('sl,r().s
hablendo ni si lo que estatllos tliciendL es cerdad'
BEnrn.rxo Russl-r-. Recientes palabras sobre los Prrcpios tle lvlatentticas, 1901
Las falacias y pi{ias aritmticas generalmente provienen de la diferencia entre la precisin
limitada de la aritmtica del computador y la precisin ilimitada de la aritmtica naturrl.
PiJia: Ottitlar que Ia stunn en ptutto
Jlotante
tto es asocicttim.
lPor
cttnsiguierie.
\ *
{,r'
+ z) +
(.r-
-
it+
--.]
Dado el gran rango de nmeros que se pueden representar en punto flotante. los
problemas se presentan cuando se suman dos nmeros grandes de
-signos
opllestos con tln
nrn"ro paquaRo. Por ejeniplo. sllpongamos -\
:
-
1'50'".
x
103s,
-]'
:
1'-5i".
x
103s,
y:
:
1.0, y que stos son todos nmeros en simple precisin. Entonces
,, * (t'*:)
:
-1.50'".
x
1038 + (1.5di", x
1033 + 1'0)
:
-1.5i".
x
1038 + (1.5di", x
l03s)
:0.0
(.r * t')
+:: (-1.5,ri". x
1018 * 1.5",
x
1038) + 1.0
:
(0.0i".)+ 1.0: 1.0
Como los nmeros en punto flotante tienen precisin limitada
1'dan
como resultado ttnr
aproximacin de resultados reales. 1'5r,..
x
l0l8 es mucho ma).or que l'0.1'.'' eSe
1.5ai.,
x
1038 + 1.0 es todavia 1.56n
x
1038. Esto es por lo que la suma de x, y y z es 0.0
o 1.0, dependiendo del orden de las sumas en punto flotante.
Falacia: Igual que una nstuccin de despla:arniento a la izquierda puede susttuir una
multiplicacin entera por una potencia de 2. un desplazamiento a la derecha es igual que una
diuisin entera por una potencia de 2.
Recordar que un nmero binario x, donde .ri significa el bit i-simo, representa el nmero:
... + (x3 x
23) + (.x2 x
2:) + (.rl x
21) + (x0 x
20)
Desplazar los bits de x a la derecha n bits sera lo mismo que dividir por 2". Y esto es
cierto para los enteros sin signo. El problema se presenta con los enteros con signo. Por
ejemplo, supongamos que queremos dividir
-
5,i.. por 40i..; el cociente sera
-
16.,. La
representacin en complemento a dos de
-
50,.. es
1111 1111 1111 1111 1111 1111 1111 1011d.,
De acuerdo con esta falacia, desplazar a la derecha dos posiciones dividira por 40,,.(22)'.
0011 1111 1111 1111 1111 1111 1111 1110d",
Con un 0 en el bit de signo, este resultado es claramente errneo. El valor creado por el
desplazamiento a la derecha es realmente I.073.741.822i", en lugar de
-
16.,.
Quiz
la solucin sera tener un desplazamiento aritmtico a la derecha (vase pgi-
na 184) que extienda el bit de signo a la derecha en lugar de desplazar 0 (ceros). Un
desplazamiento aritmtico a la derecha de 2 bits de
-
56.. produce
1111 1111 1111 1111 1111 1111 1111 111odi",
El resultado 0S
-
2". en lugar de
-
16.,; cercano pero no lo suficientemente bueno.
''
4.10. Observacones finales
La aritmtica de computadores se distingue de la aritmtica de papel y lpiz por las
li_eaduras de precisin limitada. Este limite puede producir como consecuencia operacio-
nes invlidas al calcular nmeros mayores que los lmites predefinidos. Estas anomalias,
denominadas desbordamiento o desbordamiento a cero, pueden producir excepciones o
interrupciones, eventos de emergencia similares a las llamadas a las subrutinas no planifi-
cadas. El Captulo 5 explica las excepciones con ms detalle. La aritmtica de punto
flotante tiene la dificultad aadida de ser una aproximacin de los nmeros reales. y es
necesario tener cuidado para asegurar que el nmero del computador seleccionado es ia
representacin ms cercana al nmero real. Las diflcultades de imprecisin y representa-
cin limitada son parte de la inspiracin en el campo del anlisis numrico.

Aritmetica para Computadoras y Familias PDF

Загружено:

Сведения о документе

Оригинальное название

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Aritmetica para Computadoras y Familias PDF

Загружено:

Авторское право:

Доступные форматы

UilIVERSIDAD ilACTO}IAt DE IIIGEIITERIA

Forultod de Ingenierio Elcriro y Electrnico

programacin sera an ms dificii.

La Figura 4.40 resume la parte de punto flotante de la arquitectura ivllPS revelada en

Вам также может понравиться