diff options
Diffstat (limited to 'Bachelor/BSc-Arbeit/mat_bsc_arbeit/Quellen/SUN-1999.ps')
| -rw-r--r-- | Bachelor/BSc-Arbeit/mat_bsc_arbeit/Quellen/SUN-1999.ps | 14251 |
1 files changed, 14251 insertions, 0 deletions
diff --git a/Bachelor/BSc-Arbeit/mat_bsc_arbeit/Quellen/SUN-1999.ps b/Bachelor/BSc-Arbeit/mat_bsc_arbeit/Quellen/SUN-1999.ps new file mode 100644 index 0000000..22fca8d --- /dev/null +++ b/Bachelor/BSc-Arbeit/mat_bsc_arbeit/Quellen/SUN-1999.ps @@ -0,0 +1,14251 @@ +%!PS-Adobe-1.0 +%%Creator: setsuko:vss (V.S.Sunderam,216 Fishburne,7275926,2974135) +%%Title: stdin (ditroff) +%%CreationDate: Sun Aug 5 09:43:41 1990 +%%EndComments +% Start of psdit.pro -- prolog for ditroff translator +% Copyright (c) 1985,1987 Adobe Systems Incorporated. All Rights Reserved. +% GOVERNMENT END USERS: See Notice file in TranScript library directory +% -- probably /usr/lib/ps/Notice +% RCS: $Header: psdit.pro,v 2.2 87/11/17 16:40:42 byron Rel $ +/$DITroff 140 dict def $DITroff begin + +%% Psfig additions +/DocumentInitState [ matrix currentmatrix currentlinewidth currentlinecap +currentlinejoin currentdash currentgray currentmiterlimit ] cvx def + +/startFig { + /SavedState save def + userdict maxlength dict begin + currentpoint transform + + DocumentInitState setmiterlimit setgray setdash setlinejoin setlinecap + setlinewidth setmatrix + + itransform moveto + + /ury exch def + /urx exch def + /lly exch def + /llx exch def + /y exch 72 mul resolution div def + /x exch 72 mul resolution div def + + currentpoint /cy exch def /cx exch def + + /sx x urx llx sub div def % scaling for x + /sy y ury lly sub div def % scaling for y + + sx sy scale % scale by (sx,sy) + + cx sx div llx sub + cy sy div ury sub translate + + /DefFigCTM matrix currentmatrix def + + /initmatrix { + DefFigCTM setmatrix + } def + /defaultmatrix { + DefFigCTM exch copy + } def + + /initgraphics { + DocumentInitState setmiterlimit setgray setdash + setlinejoin setlinecap setlinewidth setmatrix + DefFigCTM setmatrix + } def + + /showpage { + initgraphics + } def + +} def +% Args are llx lly urx ury (in figure coordinates) +/clipFig { + currentpoint 6 2 roll + newpath 4 copy + 4 2 roll moveto + 6 -1 roll exch lineto + exch lineto + exch lineto + closepath clip + newpath + moveto +} def +% doclip, if called, will always be just after a `startfig' +/doclip { llx lly urx ury clipFig } def +/endFig { + end SavedState restore +} def +/globalstart { + % Push details about the enviornment on the stack. + fontnum fontsize fontslant fontheight firstpage + mh my resolution slotno currentpoint + pagesave restore gsave +} def +/globalend { + grestore moveto + /slotno exch def /resolution exch def /my exch def + /mh exch def /firstpage exch def /fontheight exch def + /fontslant exch def /fontsize exch def /fontnum exch def + F + /pagesave save def +} def + +%% end XMOD additions + +/fontnum 1 def /fontsize 10 def /fontheight 10 def /fontslant 0 def +/xi {0 72 11 mul translate 72 resolution div dup neg scale 0 0 moveto + /fontnum 1 def /fontsize 10 def /fontheight 10 def /fontslant 0 def F + /pagesave save def}def +/PB{save /psv exch def currentpoint translate + resolution 72 div dup neg scale 0 0 moveto}def +/PE{psv restore}def +/m1 matrix def /m2 matrix def /m3 matrix def /oldmat matrix def +/tan{dup sin exch cos div}bind def +/point{resolution 72 div mul}bind def +/dround {transform round exch round exch itransform}bind def +/xT{/devname exch def}def +/xr{/mh exch def /my exch def /resolution exch def}def +/xp{}def +/xs{docsave restore end}def +/xt{}def +/xf{/fontname exch def /slotno exch def fontnames slotno get fontname eq not + {fonts slotno fontname findfont put fontnames slotno fontname put}if}def +/xH{/fontheight exch def F}bind def +/xS{/fontslant exch def F}bind def +/s{/fontsize exch def /fontheight fontsize def F}bind def +/f{/fontnum exch def F}bind def +/F{fontheight 0 le {/fontheight fontsize def}if + fonts fontnum get fontsize point 0 0 fontheight point neg 0 0 m1 astore + fontslant 0 ne{1 0 fontslant tan 1 0 0 m2 astore m3 concatmatrix}if + makefont setfont .04 fontsize point mul 0 dround pop setlinewidth}bind def +/X{exch currentpoint exch pop moveto show}bind def +/N{3 1 roll moveto show}bind def +/Y{exch currentpoint pop exch moveto show}bind def +/S /show load def +/ditpush{}def/ditpop{}def +/AX{3 -1 roll currentpoint exch pop moveto 0 exch ashow}bind def +/AN{4 2 roll moveto 0 exch ashow}bind def +/AY{3 -1 roll currentpoint pop exch moveto 0 exch ashow}bind def +/AS{0 exch ashow}bind def +/MX{currentpoint exch pop moveto}bind def +/MY{currentpoint pop exch moveto}bind def +/MXY /moveto load def +/cb{pop}def % action on unknown char -- nothing for now +/n{}def/w{}def +/p{pop showpage pagesave restore /pagesave save def}def +/abspoint{currentpoint exch pop add exch currentpoint pop add exch}def +/dstroke{currentpoint stroke moveto}bind def +/Dl{2 copy gsave rlineto stroke grestore rmoveto}bind def +/arcellipse{oldmat currentmatrix pop + currentpoint translate 1 diamv diamh div scale /rad diamh 2 div def + rad 0 rad -180 180 arc oldmat setmatrix}def +/Dc{gsave dup /diamv exch def /diamh exch def arcellipse dstroke + grestore diamh 0 rmoveto}def +/De{gsave /diamv exch def /diamh exch def arcellipse dstroke + grestore diamh 0 rmoveto}def +/Da{currentpoint /by exch def /bx exch def /fy exch def /fx exch def + /cy exch def /cx exch def /rad cx cx mul cy cy mul add sqrt def + /ang1 cy neg cx neg atan def /ang2 fy fx atan def cx bx add cy by add + 2 copy rad ang1 ang2 arcn stroke exch fx add exch fy add moveto}def +/Barray 200 array def % 200 values in a wiggle +/D~{mark}def +/D~~{counttomark Barray exch 0 exch getinterval astore /Bcontrol exch def pop + /Blen Bcontrol length def Blen 4 ge Blen 2 mod 0 eq and + {Bcontrol 0 get Bcontrol 1 get abspoint /Ycont exch def /Xcont exch def + Bcontrol 0 2 copy get 2 mul put Bcontrol 1 2 copy get 2 mul put + Bcontrol Blen 2 sub 2 copy get 2 mul put + Bcontrol Blen 1 sub 2 copy get 2 mul put + /Ybi /Xbi currentpoint 3 1 roll def def 0 2 Blen 4 sub + {/i exch def + Bcontrol i get 3 div Bcontrol i 1 add get 3 div + Bcontrol i get 3 mul Bcontrol i 2 add get add 6 div + Bcontrol i 1 add get 3 mul Bcontrol i 3 add get add 6 div + /Xbi Xcont Bcontrol i 2 add get 2 div add def + /Ybi Ycont Bcontrol i 3 add get 2 div add def + /Xcont Xcont Bcontrol i 2 add get add def + /Ycont Ycont Bcontrol i 3 add get add def + Xbi currentpoint pop sub Ybi currentpoint exch pop sub rcurveto + }for dstroke}if}def +end +/ditstart{$DITroff begin + /nfonts 60 def % NFONTS makedev/ditroff dependent! + /fonts[nfonts{0}repeat]def + /fontnames[nfonts{()}repeat]def +/docsave save def +}def + +% character outcalls +/oc {/pswid exch def /cc exch def /name exch def + /ditwid pswid fontsize mul resolution mul 72000 div def + /ditsiz fontsize resolution mul 72 div def + ocprocs name known{ocprocs name get exec}{name cb} + ifelse}def +/fractm [.65 0 0 .6 0 0] def +/fraction + {/fden exch def /fnum exch def gsave /cf currentfont def + cf fractm makefont setfont 0 .3 dm 2 copy neg rmoveto + fnum show rmoveto currentfont cf setfont(\244)show setfont fden show + grestore ditwid 0 rmoveto} def +/oce {grestore ditwid 0 rmoveto}def +/dm {ditsiz mul}def +/ocprocs 50 dict def ocprocs begin +(14){(1)(4)fraction}def +(12){(1)(2)fraction}def +(34){(3)(4)fraction}def +(13){(1)(3)fraction}def +(23){(2)(3)fraction}def +(18){(1)(8)fraction}def +(38){(3)(8)fraction}def +(58){(5)(8)fraction}def +(78){(7)(8)fraction}def +(sr){gsave .05 dm .16 dm rmoveto(\326)show oce}def +(is){gsave 0 .15 dm rmoveto(\362)show oce}def +(->){gsave 0 .02 dm rmoveto(\256)show oce}def +(<-){gsave 0 .02 dm rmoveto(\254)show oce}def +(==){gsave 0 .05 dm rmoveto(\272)show oce}def +end +% DIThacks fonts for some special chars +50 dict dup begin +/FontType 3 def +/FontName /DIThacks def +/FontMatrix [.001 0.0 0.0 .001 0.0 0.0] def +/FontBBox [-220 -280 900 900] def% a lie but ... +/Encoding 256 array def +0 1 255{Encoding exch /.notdef put}for +Encoding + dup 8#040/space put %space + dup 8#110/rc put %right ceil + dup 8#111/lt put %left top curl + dup 8#112/bv put %bold vert + dup 8#113/lk put %left mid curl + dup 8#114/lb put %left bot curl + dup 8#115/rt put %right top curl + dup 8#116/rk put %right mid curl + dup 8#117/rb put %right bot curl + dup 8#120/rf put %right floor + dup 8#121/lf put %left floor + dup 8#122/lc put %left ceil + dup 8#140/sq put %square + dup 8#141/bx put %box + dup 8#142/ci put %circle + dup 8#143/br put %box rule + dup 8#144/rn put %root extender + dup 8#145/vr put %vertical rule + dup 8#146/ob put %outline bullet + dup 8#147/bu put %bullet + dup 8#150/ru put %rule + dup 8#151/ul put %underline + pop +/DITfd 100 dict def +/BuildChar{0 begin + /cc exch def /fd exch def + /charname fd /Encoding get cc get def + /charwid fd /Metrics get charname get def + /charproc fd /CharProcs get charname get def + charwid 0 fd /FontBBox get aload pop setcachedevice + 40 setlinewidth + newpath 0 0 moveto gsave charproc grestore + end}def +/BuildChar load 0 DITfd put +%/UniqueID 5 def +/CharProcs 50 dict def +CharProcs begin +/space{}def +/.notdef{}def +/ru{500 0 rls}def +/rn{0 750 moveto 500 0 rls}def +/vr{20 800 moveto 0 -770 rls}def +/bv{20 800 moveto 0 -1000 rls}def +/br{20 770 moveto 0 -1040 rls}def +/ul{0 -250 moveto 500 0 rls}def +/ob{200 250 rmoveto currentpoint newpath 200 0 360 arc closepath stroke}def +/bu{200 250 rmoveto currentpoint newpath 200 0 360 arc closepath fill}def +/sq{80 0 rmoveto currentpoint dround newpath moveto + 640 0 rlineto 0 640 rlineto -640 0 rlineto closepath stroke}def +/bx{80 0 rmoveto currentpoint dround newpath moveto + 640 0 rlineto 0 640 rlineto -640 0 rlineto closepath fill}def +/ci{355 333 rmoveto currentpoint newpath 333 0 360 arc + 50 setlinewidth stroke}def + +/lt{20 -200 moveto 0 550 rlineto currx 800 2cx s4 add exch s4 a4p stroke}def +/lb{20 800 moveto 0 -550 rlineto currx -200 2cx s4 add exch s4 a4p stroke}def +/rt{20 -200 moveto 0 550 rlineto currx 800 2cx s4 sub exch s4 a4p stroke}def +/rb{20 800 moveto 0 -500 rlineto currx -200 2cx s4 sub exch s4 a4p stroke}def +/lk{20 800 moveto 20 300 -280 300 s4 arcto pop pop 1000 sub + currentpoint stroke moveto + 20 300 4 2 roll s4 a4p 20 -200 lineto stroke}def +/rk{20 800 moveto 20 300 320 300 s4 arcto pop pop 1000 sub + currentpoint stroke moveto + 20 300 4 2 roll s4 a4p 20 -200 lineto stroke}def +/lf{20 800 moveto 0 -1000 rlineto s4 0 rls}def +/rf{20 800 moveto 0 -1000 rlineto s4 neg 0 rls}def +/lc{20 -200 moveto 0 1000 rlineto s4 0 rls}def +/rc{20 -200 moveto 0 1000 rlineto s4 neg 0 rls}def +end + +/Metrics 50 dict def Metrics begin +/.notdef 0 def +/space 500 def +/ru 500 def +/br 0 def +/lt 250 def +/lb 250 def +/rt 250 def +/rb 250 def +/lk 250 def +/rk 250 def +/rc 250 def +/lc 250 def +/rf 250 def +/lf 250 def +/bv 250 def +/ob 350 def +/bu 350 def +/ci 750 def +/bx 750 def +/sq 750 def +/rn 500 def +/ul 500 def +/vr 0 def +end + +DITfd begin +/s2 500 def /s4 250 def /s3 333 def +/a4p{arcto pop pop pop pop}def +/2cx{2 copy exch}def +/rls{rlineto stroke}def +/currx{currentpoint pop}def +/dround{transform round exch round exch itransform} def +end +end +/DIThacks exch definefont pop + +ditstart +(psc)xT +576 1 1 xr +1(Times-Roman)xf 1 f +2(Times-Italic)xf 2 f +3(Times-Bold)xf 3 f +4(Times-BoldItalic)xf 4 f +5(Helvetica)xf 5 f +6(Helvetica-Bold)xf 6 f +7(Courier)xf 7 f +8(Courier-Bold)xf 8 f +9(Symbol)xf 9 f +10(DIThacks)xf 10 f +10 s +1 f +xi +%%EndProlog + +%%Page: 1 1 +10 s 10 xH 0 xS 1 f +3 f +12 s +1108 984(PVM)N +1351(:)X +1407(A)X +1500(Framework)X +2010(for)X +2157(Parallel)X +2503(Distributed)X +2996(Computing)X +1 f +10 s +3459(*)X +2 f +2057 1296(V.)N +2146(S.)X +2226(Sunderam)X +1 f +1603 1440(Department)N +2002(of)X +2089(Math)X +2278(and)X +2414(Computer)X +2754(Science)X +1690 1536(Emory)N +1928(University,)X +2306(Atlanta,)X +2582(GA)X +2718(30322)X +2 f +2115 1920(ABSTRACT)N +1 f +11 s +1064 2128(The)N +3 f +9 s +1229(PVM)X +1 f +11 s +1425(system)X +1702(is)X +1793(a)X +1864(programming)X +2376(environment)X +2854(for)X +2988(the)X +3128(development)X +3617(and)X +864 2240(execution)N +1257(of)X +1380(large)X +1606(concurrent)X +2032(or)X +2155(parallel)X +2470(applications)X +2947(that)X +3130(consist)X +3425(of)X +3548(many)X +864 2352(interacting,)N +1291(but)X +1431(relatively)X +1792(independent,)X +2273(components.)X +2771(It)X +2853(is)X +2940(intended)X +3272(to)X +3369(operate)X +3656(on)X +864 2464(a)N +927(collection)X +1299(of)X +1395(heterogeneous)X +1926(computing)X +2327(elements)X +2664(interconnected)X +3206(by)X +3317(one)X +3467(or)X +3563(more)X +864 2576(networks.)N +1233(The)X +1396(participating)X +1869(processors)X +2265(may)X +2443(be)X +2552(scalar)X +2783(machines,)X +3164(multiprocessors,)X +864 2688(or)N +961(special-purpose)X +1537(computers,)X +1949(enabling)X +2276(application)X +2692(components)X +3141(to)X +3233(execute)X +3525(on)X +3636(the)X +864 2800(architecture)N +1311(most)X +1514(appropriate)X +1947(to)X +2048(the)X +2188(algorithm.)X +3 f +9 s +2600(PVM)X +1 f +11 s +2796(provides)X +3131(a)X +3202(straightforward)X +864 2912(and)N +1020(general)X +1308(interface)X +1645(that)X +1807(permits)X +2101(the)X +2238(description)X +2659(of)X +2761(various)X +3049(types)X +3264(of)X +3366(algorithms)X +864 3024(\(and)N +1044(their)X +1230(interactions\),)X +1718(while)X +1939(the)X +2072(underlying)X +2479(infrastructure)X +2978(permits)X +3268(the)X +3401(execution)X +864 3136(of)N +964(applications)X +1418(on)X +1533(a)X +1599(virtual)X +1857(computing)X +2262(environment)X +2734(that)X +2893(supports)X +3217(multiple)X +3539(paral-)X +864 3248(lel)N +991(computation)X +1471(models.)X +3 f +9 s +1800(PVM)X +1 f +11 s +2002(contains)X +2334(facilities)X +2677(for)X +2817(concurrent,)X +3253(sequential,)X +3671(or)X +864 3360(conditional)N +1285(execution)X +1651(of)X +1747(application)X +2163(components,)X +2633(is)X +2714(portable)X +3025(to)X +3116(a)X +3177(variety)X +3444(of)X +3539(archi-)X +864 3472(tectures,)N +1182(and)X +1331(supports)X +1651(certain)X +1913(forms)X +2140(of)X +2235(error)X +2427(detection)X +2773(and)X +2922(recovery.)X +3 f +576 4044(1.)N +686(Introduction)X +1 f +776 4296(In)N +882(recent)X +1130(years,)X +1371(parallel)X +1670(and)X +1831(distributed)X +2243(processing)X +2653(have)X +2853(been)X +3053(conjectured)X +3498(to)X +3601(be)X +3718(the)X +3860(most)X +576 4408(promising)N +963(solution)X +1277(to)X +1375(the)X +1512(computing)X +1919(requirements)X +2408(of)X +2510(the)X +2647(future.)X +2908(Signi\256cant)X +3320(advances)X +3670(in)X +3767(parallel)X +576 4520(algorithms)N +986(and)X +1145(architectures)X +1627(have)X +1825(demonstrated)X +2332(the)X +2472(potential)X +2814(for)X +2948(applying)X +3290(concurrent)X +3699(computa-)X +576 4632(tion)N +737(techniques)X +1137(to)X +1229(a)X +1290(wide)X +1483(variety)X +1750(of)X +1845(problems.)X +2217(However,)X +2582(most)X +2776(of)X +2871(the)X +3001(research)X +3315(efforts)X +3566(have)X +3754(concen-)X +576 4744(trated)N +799(either)X +1022(upon)X +2 f +1220(computational)X +1752(models)X +1 f +2023([1],)X +2169(parallel)X +2457(versions)X +2773(of)X +2 f +2869(algorithms)X +1 f +3251(,)X +3296(or)X +3392(machine)X +2 f +3714(architec-)X +576 4856(tures)N +1 f +(;)S +802(relatively)X +1161(little)X +1349(attention)X +1683(has)X +1824(been)X +2014(given)X +2234(to)X +2327(software)X +2653(development)X +3133(environments)X +3637(or)X +3734(program)X +576 4968(construction)N +1047(techniques)X +1459(that)X +1627(are)X +1770(required)X +2099(in)X +2204(order)X +2425(to)X +2530(translate)X +2865(algorithms)X +3279(into)X +3453(operational)X +3886(pro-)X +576 5080(grams.)N +842(This)X +1028(aspect)X +1277(is)X +1365(becoming)X +1742(more)X +1952(important)X +2325(as)X +2426(parallel)X +2719(processing)X +3123(progresses)X +3521(from)X +3720(the)X +3856(solu-)X +576 5192(tion)N +742(of)X +843(stand-alone,)X +1299 0.2788(mathematically)AX +1873(precise,)X +2172(problems)X +2529(to)X +2627(larger)X +2861(and)X +3017(more)X +3227(complex)X +3560(software)X +3891(sys-)X +576 5304(tems.)N +820(Such)X +1050(systems)X +1383(often)X +1618(consist)X +1917(of)X +2044(many)X +2294(interacting)X +2726(components,)X +3228(each)X +3443(with)X +3654(its)X +3792(unique)X +8 s +10 f +576 5384(hhhhhhhhhhhhhhhhhh)N +1 f +656 5478(*)N +720(Research)X +974(performed)X +1261(at)X +1329(the)X +1429(Mathematical)X +1802(Sciences)X +2047(Section)X +2261(of)X +2336(Oak)X +2464(Ridge)X +2639(National)X +2881(Laboratory)X +3186(under)X +3353(the)X +3453(auspices)X +3691(of)X +576 5558(the)N +691(Faculty)X +920(Research)X +1190(Participation)X +1554(Program)X +1811(of)X +1900(Oak)X +2042(Ridge)X +2231(Associated)X +2547(Universities,)X +2908(and)X +3036(supported)X +3324(by)X +3424(the)X +3538(Applied)X +576 5638(Mathematical)N +952(Sciences)X +1201(subprogram)X +1532(of)X +1611(the)X +1715(Of\256ce)X +1900(of)X +1979(Energy)X +2189(Research,)X +2464(U.S.)X +2604(Department)X +2931(of)X +3010(Energy,)X +3236(under)X +3407(contract)X +3638(DE-)X +576 5718(AC05-84OR21400)N +1079(with)X +1209(Martin)X +1399(Marietta)X +1631(Energy)X +1831(Systems,)X +2077(Inc.)X + +2 p +%%Page: 2 2 +8 s 8 xH 0 xS 1 f +11 s +2231 400(-)N +2282(2)X +2348(-)X +576 688(requirements.)N +1091(These)X +1334(requirements)X +1827(are)X +1967(often)X +2181(diverse)X +2469(enough)X +2762(that)X +2929(it)X +3013(is)X +3106(dif\256cult)X +3420(to)X +3523(program)X +3855(them)X +576 800(within)N +832(a)X +901(uni\256ed)X +1176(framework,)X +1613(and)X +1770(cumbersome,)X +2272(and)X +2429(sometime)X +2803(impractical,)X +3253(to)X +3352(execute)X +3650(the)X +3787(system)X +576 912(on)N +686(a)X +747(single)X +980(machine.)X +776 1164(An)N +910(example)X +1236(of)X +1336(such)X +1524(a)X +1590(system)X +1862(is)X +1948(the)X +2083(\257uid)X +2273(dynamics)X +2639(application)X +3060(termed)X +3333(BF3D,)X +3598(described)X +3963(in)X +576 1276([17].)N +777(This)X +967(application)X +1393(is)X +1485(not)X +1630(only)X +1819(compute)X +2155(intensive;)X +2531(it)X +2613(uses)X +2796(large)X +3004(amounts)X +3335(of)X +3440(memory,)X +3788(creates)X +576 1388(very)N +755(large)X +954(quantities)X +1322(of)X +1419(output)X +1669(data,)X +1862(and)X +2013(requires)X +2320(2D)X +2451(and)X +2602(3D)X +2733(graphics)X +3055(terminals)X +3408(to)X +3501(display)X +3780(results.)X +576 1500(The)N +744(algorithm)X +1119(essentially)X +1523(involves)X +1853(the)X +1992(solution)X +2308(of)X +2411(a)X +2480(set)X +2608(of)X +2711(partial)X +2967(differential)X +3389(equations)X +3757(in)X +3856(three)X +576 1612(dimensional)N +1036(space,)X +1281(by)X +1398(using)X +1618(an)X +1730(appropriately)X +2229(staggered)X +2595(grid.)X +2788(The)X +2954(algorithm)X +3327(may)X +3508(be)X +3620(parallelized)X +576 1724(in)N +679(different)X +1016(ways,)X +1252(enabling)X +1589(its)X +1706(execution)X +2082(on)X +2203(several)X +2485(categories)X +2875(of)X +2981(parallel)X +3279(machines.)X +3689(However,)X +576 1836(typical)N +840(multiprocessors)X +1421(rarely)X +1649(support)X +1936(high-bandwidth)X +2517(external)X +2825(I/O)X +2966(or)X +3063(high)X +3244(performance)X +3712(graphics,)X +576 1948(thereby)N +887(necessitating)X +1390(the)X +1545(separation)X +1954(of)X +2074(the)X +2229(computation,)X +2740(output)X +3012(management,)X +3531(and)X +3704(graphical)X +576 2060(display)N +866(components)X +1327(of)X +1435(the)X +1578(system.)X +1902(Another)X +2225(example)X +2560(of)X +2669(an)X +2788(application)X +3217(with)X +3410(differing)X +3754(require-)X +576 2172(ments)N +822(for)X +959(individual)X +1353(sub-algorithms)X +1917(is)X +2011(the)X +2154(Global)X +2428(Environment)X +2923(Simulation)X +3346(project)X +3625([2],)X +3783(a)X +3856(large)X +576 2284(simulation)N +979(effort)X +1203(to)X +1301(study)X +1521(contaminant)X +1988(concentrations)X +2532(and)X +2689(dispersal)X +3032(characteristics)X +3566(as)X +3669(a)X +3738(function)X +576 2396(of)N +685(various)X +980(environmental)X +1526(factors.)X +1823(The)X +1996(ideal)X +2204(computational)X +2746(requirements)X +3242(of)X +3351(this)X +3515(simulation)X +3925(are)X +576 2508(vector)N +833(processing)X +1246(\(for)X +1414(\257uid)X +1613(\257ow)X +1806(analysis\),)X +2178(distributed)X +2593(multiprocessing)X +3194(\(modeling)X +3595(contaminant)X +576 2620(transport\),)N +988(high-speed)X +1422(scalar)X +1675(computation)X +2165(\(simulation)X +2616(of)X +2737(temperature)X +3206(effects\),)X +3539(and)X +3713(real-time)X +576 2732(graphics)N +896(for)X +1020(user)X +1188(interaction.)X +776 2984(From)N +989(a)X +1050(different)X +1375(point)X +1579(of)X +1674(view,)X +1889(many)X +2107(applications)X +2556(that)X +2711(are)X +2840(amenable)X +3200(to)X +3291(concurrent)X +3689(execution)X +576 3096(can)N +722(be)X +829(programmed)X +1303(using)X +1518(either)X +1742(message)X +2063(passing)X +2350(or)X +2446(shared)X +2698(memory)X +3015(algorithms;)X +3441(when)X +3654(computing)X +576 3208(environments)N +1091(supporting)X +1503(both)X +1695(are)X +1837(available,)X +2213(a)X +2287(hybrid)X +2552(algorithm,)X +2953(at)X +3052(a)X +3126(suf\256ciently)X +3558(high)X +3751(level)X +3959(of)X +576 3320(granularity,)N +1011(may)X +1189(be)X +1298(used)X +1484(to)X +1578(advantage.)X +1982(A)X +2070(straightforward,)X +2659(but)X +2797(illustrative)X +3201(example)X +3525(is)X +3609(matrix)X +3865(mul-)X +576 3432 0.3250(tiplication)AN +958(using)X +1171(subblock)X +1511(decompositions)X +2087([18].)X +2277(In)X +2372(an)X +2478(environment)X +2947(consisting)X +3328(of)X +3424(different)X +3750(types)X +3959(of)X +576 3544(scalar)N +812(machines)X +1176(and)X +1334(multiprocessors,)X +1944(highly)X +2200(effective)X +2538(and)X +2695(ef\256cient)X +3014(algorithms)X +3422(for)X +3554(matrix)X +3815(multi-)X +576 3656(plication)N +915(can)X +1067(be)X +1180(implemented,)X +1694(with)X +1881(some)X +2097(subblocks)X +2479(being)X +2705 0.3681(multiplied)AX +3100(using)X +3321(static)X +3538(prescheduling)X +576 3768(on)N +712(shared)X +989(memory)X +1331(machines)X +1712(and)X +1886(others)X +2148(using)X +2386 0.1974("pipe-multiply-roll")AX +3139(strategies)X +3519(on)X +3654(distributed)X +576 3880(memory)N +892(computers.)X +1303(Empirical)X +1674(results)X +1926(obtained)X +2252(by)X +2362(using)X +2575(this)X +2725(approach)X +3069(are)X +3198(presented)X +3557(in)X +3648(Section)X +3935(5.)X +776 4132(It)N +857(should)X +1119(be)X +1229(noted)X +1452(that)X +1612(most)X +1811(typical)X +2079(computing)X +2484(environments)X +2992(already)X +3279(possess)X +3570(the)X +3706(hardware)X +576 4244(diversity)N +911(required)X +1230(to)X +1325(solve)X +1537(such)X +1724(large,)X +1948(parallel)X +2239(applications,)X +2714(and)X +2867(also)X +3035(contain)X +3320(support)X +3609(for)X +3736(multiple)X +576 4356(concurrent)N +989(computation)X +1468(models.)X +1783(High)X +1997(speed)X +2235(local)X +2445(networks)X +2805(with)X +3000(graphics)X +3336(workstations,)X +3846(high-)X +576 4468(performance)N +1046(scalar)X +1277(engines,)X +1594(an)X +1703(occasional)X +2101(multiprocessor,)X +2673(and)X +2826(perhaps)X +3125(a)X +3189(vector)X +3434(computer)X +3792(are)X +3924(the)X +576 4580(norm)N +786(rather)X +1015(than)X +1191(the)X +1323(exception,)X +1712(and)X +1863(will)X +2025(continue)X +2353(to)X +2446(be)X +2553(over)X +2733(the)X +2865(next)X +3041(few)X +3197(years.)X +3429(However,)X +3797(to)X +3891(har-)X +576 4692(ness)N +759(this)X +919(collection)X +1300(of)X +1405(capabilities)X +1840(and)X +1999(to)X +2100(utilize)X +2354(it)X +2436(productively)X +2913(requires)X +3227(considerable)X +3703(efforts)X +3963(in)X +576 4804(coordination)N +1047(and)X +1199(reconciliation)X +1710(between)X +2028(different)X +2356(computation)X +2823(models)X +3103(and)X +3255(architectures)X +3730(\320)X +3844(all)X +3959(of)X +576 4916(which)N +815(has)X +956(to)X +1049(be)X +1156(done)X +1351(manually.)X +1748(The)X +3 f +9 s +1905(PVM)X +1 f +11 s +2093(\(Parallel)X +2416(Virtual)X +2689(Machine\))X +3049(project)X +3317(is)X +3399(an)X +3505(attempt)X +3794(to)X +3886(pro-)X +576 5028(vide)N +756(a)X +823(uni\256ed)X +1096(framework)X +1510(within)X +1765(which)X +2009(large)X +2214(parallel)X +2508(systems)X +2816(can)X +2967(be)X +3079(developed)X +3470(in)X +3568(a)X +3636(straightfor-)X +576 5140(ward)N +774(and)X +924(ef\256cient)X +1236(manner.)X +1545(The)X +1705(overall)X +1973(objective)X +2319(of)X +2414(this)X +2564(project)X +2831(is)X +2912(to)X +3003(permit)X +3256(a)X +3317(collection)X +3688(of)X +3783(hetero-)X +576 5252(geneous)N +906(machines)X +1281(on)X +1411(a)X +1492(network)X +1822(to)X +1933(be)X +2058(viewed)X +2354(as)X +2469(a)X +2550(general)X +2851(purpose)X +3171(concurrent)X +3590(computation)X +576 5364(resource.)N +918(Application)X +1358(algorithms)X +1759(are)X +1889(expressed)X +2258(using)X +2472(the)X +2603(most)X +2798(suitable)X +3095(paradigm;)X +3475(the)X +3 f +9 s +3601(PVM)X +1 f +11 s +3787(system)X +576 5476(executes)N +913(them)X +1124(on)X +1246(the)X +1388(most)X +1594(appropriate)X +2029(hardware)X +2389(available,)X +2764(either)X +2999(directly)X +3304(or)X +3412(by)X +3535(emulating)X +3924(the)X +576 5588(particular)N +962(computation)X +1452(model.)X +1765(Furthermore,)X +2275(it)X +2372(is)X +2478(frequently)X +2887(desired)X +3188(to)X +3304(incorporate)X +3752(existing)X +576 5700(software)N +917(\(preferably)X +1346(with)X +1542(little)X +1745(or)X +1857(no)X +1984(modi\256cations\))X +2533(into)X +2710(a)X +2788(larger)X +3032(system;)X +3341(the)X +3 f +9 s +3484(PVM)X +1 f +11 s +3688(system)X +3973(is)X +576 5812(designed)N +911(to)X +1002(enable)X +1254(this)X +1404(in)X +1495(a)X +1556(convenient)X +1965(and)X +2114(natural)X +2381(manner.)X + +3 p +%%Page: 3 3 +11 s 11 xH 0 xS 1 f +2231 400(-)N +2282(3)X +2348(-)X +776 688(The)N +3 f +9 s +940(PVM)X +1 f +11 s +1135(system)X +1411(provides)X +1745(a)X +1815(set)X +1944(of)X +2048(user)X +2225(interface)X +2564(primitives)X +2954(that)X +3118(may)X +3302(be)X +3417(incorporated)X +3894(into)X +576 800(existing)N +880(procedural)X +1280(languages.)X +1677(Primitives)X +2064(exist)X +2254(for)X +2379(the)X +2510(invocation)X +2906(of)X +3002(processes,)X +3383(message)X +3704(transmis-)X +576 912(sion)N +766(and)X +936(reception,)X +1329(broadcasting,)X +1845(synchronization)X +2452(via)X +2604(barriers,)X +2938(mutual)X +3228(exclusion,)X +3632(and)X +3803(shared)X +576 1024(memory.)N +923(Processes)X +1295(may)X +1478(be)X +1592(initiated)X +1913(synchronously)X +2456(or)X +2559(asynchronously,)X +3163(and)X +3320(may)X +3502(be)X +3615(conditioned)X +576 1136(upon)N +789(the)X +934 0.3681(initiation)AX +1292(or)X +1402(termination)X +1847(of)X +1957(another)X +2258(process,)X +2581(or)X +2692(upon)X +2906(the)X +3052 0.2898(availability)AX +3489(of)X +3600(data)X +3785(values.)X +576 1248(Message)N +906(transmission)X +1375(as)X +1471(well)X +1646(as)X +1742(\256le)X +1878(output)X +2127(may)X +2302(be)X +2408(preceded)X +2748(by)X +2859(invocations)X +3288(of)X +3383(specially)X +3719(provided)X +576 1360(primitives)N +964(to)X +1062(ensure)X +1320(that)X +1482(data)X +1658(is)X +1746(transmitted)X +2173(or)X +2276(stored)X +2521(in)X +2620(a)X +2689(machine)X +3018(independent)X +3479(form.)X +3724(Applica-)X +576 1472(tion)N +737(systems)X +1039(may)X +1214(be)X +1320(programmed)X +1793(using)X +2007(these)X +2211(primitives)X +2593(in)X +2684(the)X +2814(language)X +3154(of)X +3249(choice;)X +3526(different)X +3851(com-)X +576 1584(ponents)N +881(may)X +1065(even)X +1263(be)X +1378(programmed)X +1860(in)X +1961(different)X +2296(languages.)X +2702(The)X +3 f +9 s +2867(PVM)X +1 f +11 s +3063(constructs)X +3452(therefore)X +3801(permit)X +576 1696(the)N +715(most)X +918(appropriate)X +1350(programming)X +1861(paradigm)X +2225(and)X +2383(language)X +2732(to)X +2832(be)X +2946(used)X +3138(for)X +3271(each)X +3462(individual)X +3851(com-)X +576 1808(ponent)N +842(of)X +941(a)X +1006(parallel)X +1297(system,)X +1591(while)X +1814(retaining)X +2155(the)X +2290(ability)X +2544(for)X +2673(components)X +3126(to)X +3222(interact)X +3514(and)X +3668(cooperate.)X +576 1920(It)N +657(should)X +919(be)X +1029(mentioned)X +1429(that)X +1588(the)X +3 f +9 s +1718(PVM)X +1 f +11 s +1908(user-interface)X +2417(primitives)X +2802(have)X +2994(been)X +3186(partly)X +3418(derived)X +3708(from)X +3905(and)X +576 2032(are)N +718(a)X +792(superset)X +1115(of)X +1223(the)X +1366(portable)X +1690(programming)X +2205(constructs)X +2597(described)X +2969(in)X +3073([3];)X +3235(an)X +3353(application)X +3782(written)X +576 2144(using)N +806(these)X +1026(primitives)X +1424(may)X +1615(therefore)X +1971(also)X +2152(execute)X +2460(directly)X +2769(on)X +2896(a)X +2973(speci\256c)X +3280(multiprocessor)X +3842(when)X +576 2256(necessary.)N +776 2508(The)N +3 f +9 s +936(PVM)X +1 f +11 s +1127(system)X +1399(consists)X +1705(of)X +1805(support)X +2096(software)X +2425(that)X +2585(executes)X +2915(on)X +3030(participating)X +3504(hosts)X +3712(on)X +3828(a)X +3895(net-)X +576 2620(work;)N +813(the)X +953(network)X +1273(may)X +1457(be)X +1572(local,)X +1798(wide-area)X +2176(or)X +2281(a)X +2352(combination,)X +2848(and)X +3007(the)X +3147(host)X +3326(pool)X +3515(may)X +3698(be)X +3812(varied)X +576 2732(dynamically.)N +1072(Hosts)X +1309(may)X +1498(be)X +1618(scalar)X +1860(machines,)X +2252(workstations,)X +2761(or)X +2871(parallel)X +3173(processors)X +3580(\320)X +3705(the)X +3850(latter)X +576 2844(being)N +811(considered)X +1231(an)X +1353(atomic)X +1633(computational)X +2178(resource)X +2514(by)X +3 f +9 s +2637(PVM)X +1 f +11 s +2801(.)X +2862(This)X +3057(support)X +3359(software)X +3699(interprets)X +576 2956(requests)N +888(generated)X +1254(by)X +1366(the)X +1498(user-level)X +1870(constructs)X +2252(and)X +2404(carries)X +2663(out)X +2801(the)X +2934(necessary)X +3300(actions)X +3575(in)X +3669(a)X +3733(machine)X +576 3068(independent)N +1031(manner.)X +1341(The)X +3 f +9 s +1498(PVM)X +1 f +11 s +1686(software)X +2012(essentially)X +2409(consists)X +2711(of)X +2807(a)X +2869(collection)X +3241(of)X +3337(protocol)X +3654(algorithms)X +576 3180(to)N +674(implement)X +1082(reliable)X +1376(and)X +1532(sequenced)X +1927(data)X +2103(transfer,)X +2423(distributed)X +2831(consensus,)X +3239(and)X +3396(mutual)X +3672(exclusion.)X +576 3292(In)N +681(an)X +796(attempt)X +1094(to)X +1195(make)X +1418(the)X +1558(system)X +1835(as)X +1939(robust)X +2190(as)X +2294(possible,)X +2636(these)X +2848(algorithms)X +3257(also)X +3430(incorporate)X +3862(error)X +576 3404(detection)N +932(mechanisms)X +1400(\320)X +1520(process)X +1815(and)X +1975(processor)X +2344(failure)X +2607(noti\256cation)X +3043(is)X +3135(provided)X +3481(to)X +3583(applications,)X +576 3516(thereby)N +865(enabling)X +1194(them)X +1396(to)X +1490(take)X +1662(corrective)X +2039(action.)X +2302(In)X +2400(addition,)X +2736(heuristics)X +3098(are)X +3229(included)X +3557(into)X +3719(the)X +3851(algo-)X +576 3628(rithms)N +838(for)X +976(mutual)X +1259(exclusion)X +1634(and)X +1798(consensus)X +2191(that)X +2361(enable)X +2628(the)X +2773(preemption)X +3212(of)X +3322(deadlock)X +3677(in)X +3783(several)X +576 3740(situations.)N +776 3992(Several)N +1065(projects)X +1369(similar)X +1640(to)X +3 f +9 s +1730(PVM)X +1 f +11 s +1919(have)X +2110(been)X +2301(undertaken)X +2717(in)X +2811(the)X +2944(past,)X +3134(and)X +3287(some)X +3499(are)X +3632(ongoing.)X +3969(A)X +576 4104(few)N +739(representative)X +1265(examples)X +1630(are)X +1769(listed)X +1993(below,)X +2262(with)X +2451(comparisons)X +2928(to)X +3 f +9 s +3024(PVM)X +1 f +11 s +3188(.)X +3241(The)X +3409(DPUP)X +3664(library)X +3930([4])X +576 4216(emulates)N +919(a)X +987(loosely)X +1272(coupled)X +1581(multiprocessor)X +2135(on)X +2253(a)X +2322(local)X +2524(network,)X +2864(as)X +2967(does)X +3158(the)X +3296(dsim)X +3498([5])X +3630(system)X +3905(and)X +576 4328(the)N +723(Cosmic)X +1032(environment)X +1516([6].)X +1678(The)X +1853(two)X +2023(latter)X +2243(systems)X +2560(require)X +2847(the)X +2993(precon\256guration)X +3613(of)X +3724(a)X +3801(virtual)X +576 4440(machine)N +897(on)X +1007(which)X +1244(applications)X +1693(execute)X +1985(and)X +2135(support)X +2422(only)X +2602(basic)X +2806(message)X +3127(passing)X +3414(mechanisms.)X +3895(The)X +576 4552(Amber)N +859(project)X +1143([15])X +1328(is)X +1426(somewhat)X +1822(different)X +2164(in)X +2272(that)X +2444(the)X +2591(targeted)X +2914(environment)X +3398(is)X +3495(a)X +3572(collection)X +3959(of)X +576 4664(homogeneous)N +2 f +1100(multi-)X +1 f +1311(processors.)X +1738(One)X +1919(of)X +2027(the)X +2170(operating)X +2538(modes)X +2803(within)X +3065(DPUP,)X +3347(as)X +3456(well)X +3644(as)X +3753(projects)X +576 4776(such)N +762(as)X +860(Marionette)X +1272([7])X +1399(and)X +1551(MSPCM)X +1889([8],)X +2038(uses)X +2214(the)X +2347(master-slave)X +2817(approach,)X +3186(where)X +3425(a)X +3489(central)X +3753(control-)X +576 4888(ling)N +739(process)X +1027(is)X +1111(responsible)X +1537(for,)X +1686(or)X +1784(is)X +1868(involved)X +2202(in,)X +2318(every)X +2538(system)X +2808(event.)X +3046(In)X +3144(addition)X +3459(to)X +3553(affecting)X +3891(per-)X +576 5000(formance)N +942(and)X +1103(being)X +1333(an)X +1449(unnatural)X +1815(model)X +2069(for)X +2204(certain)X +2477(classes)X +2754(of)X +2860(problems,)X +3243(this)X +3404(central)X +3677(process)X +3973(is)X +576 5112(critical,)N +877(and)X +1037(its)X +1154(failure)X +1417(leads)X +1631(to)X +1733(a)X +1805(complete)X +2162(collapse)X +2484(of)X +2591(the)X +2733(entire)X +2968(system.)X +3269(Another)X +3591(shortcoming)X +576 5224(common)N +912(to)X +1008(all)X +1124(the)X +1259(above)X +1496(is)X +1582(the)X +1717(use)X +1861(of)X +1961(virtual)X +2219(circuits)X +2506(for)X +2635(network)X +2950 0.2452(communication;)AX +3552(in)X +3647(addition)X +3963(to)X +576 5336(overheads)N +954(that)X +1109(may)X +1283(not)X +1418(be)X +1523(justi\256able,)X +1916(practical)X +2242(limits)X +2467(on)X +2577(the)X +2707(number)X +2998(of)X +3093(connections)X +3537(affect)X +3760(the)X +3891(sca-)X +576 5448(lability)N +862(of)X +969(applications.)X +1474(In)X +1581(addition,)X +1927(failure)X +2191(resiliency)X +2568(and)X +2728(debugging)X +3133(support)X +3430(is)X +3522(minimal.)X +3895(The)X +3 f +9 s +576 5560(PVM)N +1 f +11 s +771(system)X +1047(is)X +1137(completely)X +1561(distributed,)X +1992(supports)X +2321(a)X +2391(dynamic)X +2726(host)X +2904(pool,)X +3114(and)X +3272(assumes)X +3596(only)X +3784(that)X +3949(an)X +576 5672(unreliable,)N +979(unsequenced)X +1460(datagram)X +1815(delivery)X +2131(mechanism)X +2560(is)X +2646(available.)X +3014(From)X +3232(the)X +3367(application's)X +3850(point)X +576 5784(of)N +671(view,)X +3 f +9 s +882(PVM)X +1 f +11 s +1068(constructs)X +1447(are)X +1576(substantially)X +2045(more)X +2248(general)X +2529(in)X +2621(nature)X +2864(and)X +3014(encompass)X +3423(both)X +3603(the)X +3734(message)X + +4 p +%%Page: 4 4 +11 s 11 xH 0 xS 1 f +2231 400(-)N +2282(4)X +2348(-)X +576 688(passing)N +867(and)X +1020(shared)X +1275(memory)X +1595(paradigms;)X +2013(yet,)X +2169(by)X +2283(substituting)X +2722(alternative)X +3121(libraries,)X +3458(unmodi\256ed)X +3886(pro-)X +576 800(grams)N +813(may)X +987(execute)X +1278(on)X +1388(speci\256c)X +1679(multiprocessors.)X +776 1052(The)N +937(following)X +1304(section)X +1578(describes)X +1929(the)X +2061(user)X +2231(interface)X +2564(and)X +2716(the)X +2849(important)X +3218(design)X +3473(aspects)X +3752(of)X +3 f +9 s +3846(PVM)X +1 f +11 s +4010(.)X +576 1164(An)N +710(overview)X +1064(of)X +1164(the)X +3 f +9 s +1295(PVM)X +1 f +11 s +1486(support)X +1777(software,)X +2128(with)X +2312(an)X +2422(emphasis)X +2777(on)X +2892(the)X +3027(protocol)X +3348(algorithms)X +3752(and)X +3905(key)X +576 1276 0.2885(implementation)AN +1158(features)X +1462(follows.)X +1774(Preliminary)X +2217(results)X +2473(and)X +2626(performance)X +3096(\256gures)X +3361(are)X +3494(then)X +3673(presented,)X +576 1388(and)N +725(the)X +855(concluding)X +1269(section)X +1541(reports)X +1807(on)X +1917(continuing)X +2317(and)X +2466(future)X +2698(work.)X +3 f +576 1724(2.)N +686(The)X +855(User)X +1052(Interface)X +1 f +776 1976(The)N +957(application)X +1394(views)X +1644(the)X +3 f +9 s +1793(PVM)X +1 f +11 s +2002(system)X +2292(as)X +2410(a)X +2494(general)X +2798(and)X +2970(\257exible)X +3280(parallel)X +3590(computation)X +576 2088(resource)N +908(that)X +1076(supports)X +1409(common)X +1753(parallel)X +2053(programming)X +2568(paradigms.)X +2991(Application)X +3442(programs)X +3808(access)X +576 2200(these)N +784(resources)X +1142(by)X +1257(invoking)X +1598(function)X +1919(calls)X +2109(from)X +2308(within)X +2562(common)X +2899(procedural)X +3303(languages)X +3683(such)X +3872(as)X +3973(C)X +576 2312(or)N +676(Fortran.)X +984(Such)X +1187(an)X +1297(interface)X +1632(was)X +1795(selected)X +2106(primarily)X +2462(for)X +2590(portability)X +2985(reasons)X +3274(\320)X +3388(most)X +3586(multiproces-)X +576 2424(sor)N +712(applications)X +1168(are)X +1304(currently)X +1651(written)X +1930(in)X +2028(procedural)X +2433(languages)X +2814(with)X +3000(embedded,)X +3413(machine-speci\256c,)X +576 2536(function)N +905(calls)X +1102(that)X +1270(perform)X +1588(process)X +1886(spawning,)X +2280(message)X +2613(reception)X +2976(and)X +3138(transmission,)X +3641(and)X +3803(shared)X +576 2648(memory)N +893(operations.)X +1305(The)X +3 f +9 s +1461(PVM)X +1 f +11 s +1648(primitives)X +2030(have)X +2220(been)X +2410(made)X +2625(the)X +2757(same)X +2962(as)X +3059(or)X +3156(very)X +3336(similar)X +3606(to)X +3699(the)X +3831(union)X +576 2760(of)N +683(these)X +898(functions,)X +1282(thereby)X +1580(enabling)X +1918(previously)X +2324(written)X +2608(applications)X +3068(to)X +3170(be)X +3286(ported)X +3544(readily)X +3822(to)X +3924(the)X +3 f +9 s +576 2872(PVM)N +1 f +11 s +764(environment.)X +1256(This)X +1437(aspect)X +1682(also)X +1849(permits)X +2139(the)X +2272(execution)X +2640(of)X +2738(applications,)X +3212(or)X +3310(components)X +3761(thereof,)X +576 2984(on)N +691(speci\256c)X +987(machines)X +1347(when)X +1564(possible.)X +1924(The)X +3 f +9 s +2083(PVM)X +1 f +11 s +2273(user)X +2445(interface)X +2779(syntax)X +3035(and)X +3188(semantics)X +3562(are)X +3695(presented)X +576 3096(in)N +667(this)X +817(section)X +1089(with)X +1268(illustrative)X +1669(examples)X +2024(using)X +2237(the)X +2367(C)X +2448(language)X +2788(interface.)X +3 f +576 3432(2.1.)N +752(Processes)X +1130(and)X +1294(Process)X +1599(Initiation)X +1 f +776 3684(In)N +879(the)X +3 f +9 s +1013(PVM)X +1 f +11 s +1207(system,)X +1504(an)X +1617(application)X +2040(is)X +2129(considered)X +2540(to)X +2639(consist)X +2914(of)X +2 f +3017(components)X +1 f +3437(.)X +3489(For)X +3641(example,)X +3993(a)X +576 3796(simulation)N +979(application)X +1401(might)X +1637(consist)X +1911(of)X +2013(a)X +2081(partial)X +2336(differential)X +2756(equation)X +3088(component,)X +3530(a)X +3597(matrix)X +3856(solu-)X +576 3908(tion)N +738(component,)X +1176(and)X +1327(a)X +1390(user)X +1560(interface)X +1892(component.)X +2352(It)X +2430(should)X +2689(be)X +2796(pointed)X +3085(out)X +3222(that)X +3379(this)X +3531(de\256nition)X +3895(of)X +3993(a)X +576 4020(component)N +993(is)X +1077(perhaps)X +1375(unconventional;)X +1969(usually,)X +2271(the)X +2404(term)X +2591(implies)X +2877(a)X +2941(phase)X +3166(or)X +3264(portion)X +3544(of)X +3641(an)X +3748(applica-)X +576 4132(tion)N +741(that)X +901(is)X +988(embodied)X +1364(in)X +1461(a)X +1528(subroutine)X +9 f +1928(-)X +1 f +2004(such)X +2193(as)X +2294("the)X +2466(forward-substitution)X +3213(component)X +3633(of)X +3734(a)X +3801(matrix)X +576 4244(solver".)N +873(However,)X +1240(the)X +3 f +9 s +1368(PVM)X +1 f +11 s +1556(system)X +1825(is)X +1908(a)X +1971(large-granularity)X +2587(environment,)X +3079(primarily)X +3432(targeted)X +3739(at)X +3826(appli-)X +576 4356(cations)N +849(that)X +1005(are)X +1135(collections)X +1542(of)X +1639(relatively)X +1997(independent)X +2452(programs.)X +2830(In)X +2927(view)X +3122(of)X +3219(this,)X +3393(a)X +3 f +9 s +3452(PVM)X +1 f +11 s +3640(component)X +576 4468(corresponds)N +1031(not)X +1175(to)X +1275(a)X +1345(phase)X +1576(in)X +1676(the)X +1815(traditional)X +2210(sense,)X +2452(but)X +2595(rather)X +2830(to)X +2929(a)X +2998(larger)X +3233(unit)X +3401(of)X +3504(an)X +3617(application.)X +576 4580(From)N +790(the)X +921(system)X +1189(point)X +1394(of)X +1490(view,)X +1706(a)X +1768(component)X +2183(corresponds)X +2630(to)X +2722(an)X +2829(object)X +3069(\256le)X +3206(that)X +3363(is)X +3446(capable)X +3739(of)X +3836(being)X +576 4692(executed)N +925(as)X +1034(a)X +1109(user-level)X +1492(process.)X +1813(A)X +1911(compiled)X +2275(C)X +2369(program)X +2702(that)X +2870(performs)X +3222(LU)X +3374(factorization)X +3855(is)X +3949(an)X +576 4804(example)N +897(of)X +992(a)X +1054(component.)X +1491(It)X +1568(is)X +1650(the)X +1781(responsibility)X +2285(of)X +2381(the)X +2512(user)X +2681(to)X +2773(compile)X +3081(component)X +3496(programs)X +3851(to)X +3943(all)X +576 4916(target)N +806(architectures)X +1285(on)X +1402(which)X +1646(that)X +1808(component)X +2229(may)X +2409(execute.)X +2728(Depending)X +3142(upon)X +3346(the)X +3482(target)X +3711(machine,)X +576 5028(the)N +719(compiled)X +1083(version)X +1377(of)X +1485(a)X +1559(component)X +1986(may)X +2173(either)X +2409(link)X +2582(against)X +2867(the)X +3 f +9 s +3007(PVM)X +1 f +11 s +3207(primitives,)X +3624(or)X +3733(machine)X +576 5140(speci\256c)N +877(libraries,)X +1220(or)X +1325(both.)X +1536(A)X +1631(component)X +2055(is)X +2146(therefore)X +2494(a)X +2564(static)X +2782(entity)X +3015(and)X +3173(is)X +3263(identi\256ed)X +3628(by)X +3747(a)X +2 f +3817(name)X +1 f +4007(;)X +576 5252(associations)N +1024(between)X +1339(component)X +1753(names)X +2000(and)X +2149(executable)X +2548(versions)X +2864(are)X +2994(set)X +3115(up)X +3226(as)X +3322(discussed)X +3682(in)X +3774(the)X +3905(fol-)X +576 5364(lowing)N +843(paragraphs.)X +776 5616(A)N +888(complete)X +1261(description)X +1703(of)X +1826(application)X +2269(components,)X +2767(i.e.)X +2925(the)X +3083(component)X +3525(name)X +3766(and)X +3943(all)X +576 5728(corresponding)N +1126(executables)X +1584(\(each)X +1820(with)X +2023(an)X +2152(architecture)X +2614(tag\),)X +2819(is)X +2924(obtained)X +3274(by)X +3408(the)X +3 f +9 s +3558(PVM)X +1 f +11 s +3768(support)X +576 5840(software.)N +935(This)X +1127(information)X +1579(is)X +1673(gathered)X +2011(either)X +2247(from)X +2454(a)X +2529(\256le)X +2678(or)X +2787(from)X +2994(a)X +3069(startup)X +3345(process,)X +3666(as)X +3775(will)X +3949(be)X + +5 p +%%Page: 5 5 +11 s 11 xH 0 xS 1 f +2231 400(-)N +2282(5)X +2348(-)X +576 688(explained)N +950(below.)X +1218(An)X +1356(example)X +1686(of)X +1790(a)X +1860(component)X +2283(description)X +2705(\256le)X +2848(is)X +2937(shown)X +3196(in)X +3295(Figure)X +3555(1.)X +3673(This)X +3860(table)X +576 800(illustrates)N +944(that)X +1101(a)X +1164(component,)X +1602(identi\256ed)X +1961(by)X +2074(a)X +2138(name,)X +2376(may)X +2553(be)X +2661(manifested)X +3073(as)X +3171(several)X +3445(different)X +3773(execut-)X +576 912(able)N +755(\256les;)X +959(and)X +1118(conversely,)X +1553(that)X +1718(multiple)X +2046(component)X +2470(names)X +2727(may)X +2911(map)X +3094(onto)X +3282(the)X +3421(same)X +3633(executable.)X +576 1024(The)N +746(\256rst)X +916(feature)X +1193(permits)X +1491(the)X +3 f +9 s +1628(PVM)X +1 f +11 s +1825(system)X +2104(to)X +2207(execute)X +2510(components)X +2970(at)X +3068(the)X +3210(most)X +3416(suitable)X +3725(location,)X +576 1136(while)N +794(the)X +924(second)X +1190(allows)X +1442(the)X +1572(user)X +1740(to)X +1831(specify)X +2107(a)X +2168(particular)X +2528(location)X +2835(as)X +2930(will)X +3090(be)X +3195(explained)X +3560(below.)X +10 f +1190 1328(i)N +1218(iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii)X +1 f +1234 1440(Name)N +1615(Location)X +2061(Object)X +2318(\256le)X +2934(Architecture)X +10 f +1190 1456(i)N +1218(iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii)X +1190 1472(i)N +1218(iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii)X +1 f +1234 1576(factor)N +1615(iPSC)X +2061(/u0/host/factor1)X +2934(ipsc)X +1234 1688(factor)N +1615(msrsun)X +2061 0.1612(/usr/alg/math/factor)AX +2934(sun3)X +1234 1800(factor)N +1615(msrsun)X +2061 0.1531(/usr/alg4/math/factor)AX +2934(sun4)X +1234 1912(chol)N +1615(csvax2)X +2061(/usr/matrix/chol)X +2934(vax)X +1234 2024(chol)N +1615(vmsvax)X +2061(JOE:CHOL.OBJ)X +2934(vms)X +1234 2136(tool)N +1615(msrsun)X +2061(/usr/view/graph/obj)X +2934(sun3)X +1234 2248(factor2)N +1615(iPSC)X +2061(/u0/host/factor1)X +2934(ipsc)X +10 f +1190 2272(i)N +1218(iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii)X +1190(c)X +2208(c)Y +2120(c)Y +2032(c)Y +1944(c)Y +1856(c)Y +1768(c)Y +1680(c)Y +1592(c)Y +1504(c)Y +1416(c)Y +3418 2272(c)N +2208(c)Y +2120(c)Y +2032(c)Y +1944(c)Y +1856(c)Y +1768(c)Y +1680(c)Y +1592(c)Y +1504(c)Y +1416(c)Y +1 f +1451 2544(Figure)N +1703(1)X +1769(:)X +1816(Example)X +2152(Component)X +2586(Description)X +3019(File)X +776 2908(A)N +2 f +862(process)X +1 f +1153(is)X +1235(an)X +1341(executing)X +1707(instance)X +2019(of)X +2115(a)X +2177(component)X +2592(and)X +2742(is)X +2824(identi\256ed)X +3181(by)X +3293(the)X +3425(component)X +3841(name)X +576 3020(and)N +736(a)X +808(positive)X +1121(instance)X +1443(number.)X +1767(Processes)X +2141(may)X +2326(be)X +2442(initiated)X +2766(from)X +2969(within)X +3227(components)X +3685(or)X +3790(from)X +3993(a)X +576 3132("startup")N +914(process)X +1203(that)X +1362(may)X +1540(be)X +1649(manually)X +2004(executed)X +2343(on)X +2457(any)X +2610(participating)X +3083(host.)X +3278(A)X +3367(process)X +3656(is)X +3741(initiated)X +576 3244(by)N +688(invoking)X +1026(the)X +3 f +1158(initiate)X +1 f +1447(primitive)X +1796(with)X +1977(the)X +2108(component)X +2523(name)X +2737(as)X +2833(an)X +2939(argument;)X +3320(the)X +3451(instance)X +3763(number)X +576 3356(of)N +676(the)X +811(initiated)X +1129(process)X +1419(is)X +1505(returned)X +1825(to)X +1921(the)X +2057(user.)X +2253(Prior)X +2457(to)X +2554(executing)X +2925(any)X +3 f +9 s +3076(PVM)X +1 f +11 s +3268(construct,)X +3641(however,)X +3993(a)X +576 3468(process)N +871(must)X +1075(invoke)X +1347(the)X +3 f +1486(enroll)X +1 f +1738(function;)X +2088(this)X +2247(establishes)X +2660(a)X +2730(\(machine)X +3089(dependent\))X +3511(mechanism)X +3944(by)X +576 3580(which)N +815(a)X +878(user)X +1048(process)X +1335(may)X +1511(communicate)X +2011(with)X +2192(the)X +3 f +9 s +2320(PVM)X +1 f +11 s +2509(system.)X +2801(A)X +2889(typical)X +3155(section)X +3430(of)X +3528(code)X +3719(executed)X +576 3692(by)N +690(a)X +754(startup)X +1019(process)X +1307(is)X +1391(shown)X +1645(in)X +1739(Figure)X +1994(2.)X +2107(It)X +2186(should)X +2446(be)X +2554(noted)X +2775(in)X +2869(the)X +3002(example)X +3326(shown)X +3580(that)X +3738(the)X +3871(phy-)X +576 3804(sical)N +770(location)X +1087(of)X +1192(the)X +1333(initiated)X +1657(processes)X +2026(is)X +2118(transparent)X +2542(to)X +2644(the)X +2785(invoking)X +3132(process;)X +3453(the)X +3 f +9 s +3590(PVM)X +1 f +11 s +3787(system)X +576 3916(determines)N +989(the)X +1123(best)X +1291(machine)X +1616(on)X +1730(which)X +1971(to)X +2066(execute)X +2361(a)X +2426(process)X +2715(based)X +2940(upon)X +3141(the)X +3274(current)X +3548(host)X +3720(pool,)X +3924(the)X +576 4028(alternative)N +994(architectures)X +1489(on)X +1622(which)X +1882(a)X +1966(component)X +2403(may)X +2600(execute,)X +2936(and)X +3109(the)X +3263(load)X +3461(factor)X +3712(on)X +3846(those)X +576 4140(machines.)N +955(However,)X +1322(a)X +1385(speci\256c)X +1678(location)X +1987(may)X +2163(be)X +2269(forced)X +2516(by)X +2627(declaring)X +2978(a)X +3040(new)X +3209(component)X +3624(name)X +3838(\(as)X +3963(in)X +576 4252(the)N +706(last)X +851(line)X +1006(of)X +1101(the)X +1231(component)X +1645(description)X +2059(\256le)X +2194(above\))X +2455(and)X +2604 0.3681(initiating)AX +2947(that)X +3102(component.)X +8 f +735 4524(...)N +735 4636 0.1985(enroll\("startup"\);)AN +735 4748(for)N +947(\(i=0;i<10;i++\))X +894 4860(instance[i])N +1530(=)X +1636 0.1979(initiate\("factor"\);)AX +735 4972(...)N +1 f +1373 5132(Figure)N +1625(2)X +1691(:)X +1738(Initiation)X +2085(of)X +2180(multiple)X +2498(component)X +2912(instances)X +2 f +776 5496(Positioning)N +1 f +1212(of)X +1313(application)X +1734(components)X +2188(on)X +2304(speci\256c)X +2601(processing)X +3005(elements)X +3348(is)X +3436(often)X +3646(a)X +3714(desirable)X +576 5608(facility,)N +881(particularly)X +1320(in)X +1420(heterogeneous)X +1959(environments.)X +2492(When)X +2733(the)X +2872(application)X +3296(has)X +3444(prior)X +3646(knowledge)X +576 5720(of)N +674(the)X +807(special)X +1077(capabilities)X +1505(of)X +1603(a)X +1667(speci\256c)X +1961(machine)X +2285(or)X +2383(even)X +2574(the)X +2707(characteristics)X +3237(of)X +3336(a)X +3401(particular)X +3765(dataset,)X +576 5832(executing)N +951(a)X +1022(component)X +1445(at)X +1540(a)X +1610(\256xed)X +1817(location)X +2133(can)X +2286(lead)X +2464(to)X +2564(signi\256cant)X +2963(bene\256ts.)X +3290(In)X +3 f +9 s +3390(PVM)X +1 f +11 s +3554(,)X +3607(this)X +3766(may)X +3949(be)X + +6 p +%%Page: 6 6 +11 s 11 xH 0 xS 1 f +2231 400(-)N +2282(6)X +2348(-)X +576 688(accomplished)N +1090(either)X +1320(statically)X +1669(as)X +1771(explained)X +2143(above,)X +2404(or)X +2506(dynamically)X +2972(by)X +3089(using)X +3309(the)X +3 f +3446(entercomp)X +1 f +3876(con-)X +576 800(struct.)N +824(Arguments)X +1245(to)X +1344(this)X +1502(construct)X +1855(are)X +1992(a)X +2060(component)X +2481(name,)X +2723(an)X +2835(object)X +3080(\256lename)X +3413(and)X +3569(location,)X +3905(and)X +576 912(an)N +686(architecture)X +1129(tag.)X +1308(This)X +1492(construct)X +1842(is)X +1928(used)X +2116(to)X +2212("register")X +2575(a)X +2641(new)X +2814(component)X +3233(that)X +3393(may)X +3572(subsequently)X +576 1024(be)N +695(executed)X +1044(by)X +1168(using)X +1394(the)X +3 f +1537(initiate)X +1 f +1837(construct.)X +2217(For)X +2374(example,)X +2730(if)X +2819(an)X +2937(executing)X +3315(component)X +3742(found)X +3982(it)X +576 1136(necessary)N +952(to)X +1056(spawn)X +1315(a)X +1389(subprocess)X +1809(on)X +1932(a)X +2006(speci\256c)X +2311(machine,)X +2668(it)X +2754(might)X +2997(use)X +3150(the)X +3294(following)X +3673(section)X +3959(of)X +576 1248(code:)N +8 f +735 1520 0.1912(entercomp\("subproc","sequent8","/usr/a.out","seq"\);)AN +735 1632 0.1974(initiate\("subproc"\);)AN +1 f +776 1932(The)N +3 f +946(initiate)X +1 f +1244(mechanism)X +1679(is,)X +1793(by)X +1914(default,)X +2214(asynchronous.)X +2752(Control)X +3055(is)X +3147(returned)X +3473(to)X +3576(the)X +3718(invoking)X +576 2044(process)N +871(as)X +975(soon)X +1172(as)X +1276(the)X +1415(instance)X +1735(number)X +2035(of)X +2139(the)X +2278(process)X +2572(is)X +2662(available.)X +3034(However,)X +3408(under)X +3639(certain)X +3910(cir-)X +576 2156(cumstances,)N +1044(it)X +1134(may)X +1326(be)X +1450(necessary)X +1832(to)X +1942(initiate)X +2230(a)X +2310(component)X +2743(only)X +2941(after)X +3143(another)X +3448(process)X +3752(has)X +3910(ter-)X +576 2268(minated.)N +938(The)X +3 f +1108(initiateP)X +1 f +1460(variant)X +1738(allows)X +2001(this)X +2162(by)X +2283(permitting)X +2685(the)X +2826(user)X +3005(to)X +3107(defer)X +3320 0.3681(initiation)AX +3674(of)X +3780(a)X +3851(com-)X +576 2380(ponent)N +838(until)X +1023(after)X +1206(another)X +1492(has)X +1631(terminated.)X +2053(For)X +2197(example,)X +8 f +735 2540 0.1937(initiateP\("factor","matmul",3\);)AN +1 f +576 2784(will)N +742(initiate)X +1017(an)X +1129(instance)X +1447(of)X +1549("factor")X +1855(only)X +2041(after)X +2231(instance)X +2549(number)X +2847(3)X +2920(of)X +3022("matmul")X +3394(has)X +3540(terminated.)X +3969(A)X +576 2896(third-argument)N +1131(value)X +1348(of)X +1447(0)X +1517(will)X +1681(cause)X +1902("factor")X +2205(to)X +2300(be)X +2409(initiated)X +2726(only)X +2909(when)X +2 f +3124(all)X +1 f +3243(instances)X +3591(of)X +3689("matmul")X +576 3008(terminate.)N +956(In)X +1053(an)X +1160(analogous)X +1541(fashion,)X +3 f +1846(initiateD)X +1 f +2198(is)X +2281(used)X +2466(to)X +2559(execute)X +2852(components)X +3302(conditional)X +3724(upon)X +3924(the)X +576 3120(occurrence)N +983(of)X +1078(a)X +1139(user-signaled)X +1630(event,)X +1865(normally)X +2206(the)X +2336 0.2898(availability)AX +2757(of)X +2852(data.)X +3043(Thus,)X +8 f +735 3280 0.1942(initiateD\("chol","dataset7"\);)AN +1 f +576 3524(will)N +761(delay)X +999(the)X +1154(execution)X +1544(of)X +1664("chol")X +1936(until)X +2147(some)X +2381(other)X +2610(process)X +2921(signals)X +3214(the)X +3370(occurrence)X +3803(of)X +3924(the)X +576 3636("dataset7")N +972(event,)X +1220(by)X +1343(invoking)X +1692(the)X +3 f +1834(ready)X +1 f +2049(\("dataset7"\))X +2502(primitive.)X +2883(All)X +3030(variants)X +3343(of)X +3 f +3450(initiate)X +1 f +3749(return)X +3993(a)X +576 3748(negative)N +897(result)X +1115(if)X +1191(a)X +1252(process)X +1537(could)X +1755(not)X +1890(be)X +1996(initiated,)X +2332(thereby)X +2619(enabling)X +2946(the)X +3077(invoker)X +3369(to)X +3461(take)X +3631(appropriate)X +576 3860(action.)N +862(The)X +1025(global)X +1272(component)X +1690(dependencies)X +2190(of)X +2289(the)X +2423(application)X +2841(may)X +3018(therefore)X +3360(be)X +3468(speci\256ed)X +3806(within)X +576 3972(a)N +640(startup)X +905(process)X +1193(by)X +1306(the)X +1440(use)X +1583(of)X +1682(appropriate)X +3 f +2109(initiate)X +1 f +2400(primitives)X +2785(or)X +2884(variants,)X +3211(embedded)X +3599(within)X +3851(com-)X +576 4084(mon)N +765(selection)X +1110(and)X +1268(iteration)X +1594(control)X +1875(\257ow)X +2062(constructs)X +2450(available)X +2800(in)X +2900(the)X +3039(host)X +3217(language.)X +3588(Of)X +3711(course,)X +3993(a)X +576 4196(component)N +991(itself)X +1191(may)X +1366(be)X +1472(composed)X +1852(of)X +1948(several)X +2220(subcomponents)X +2791(\320)X +2902(whose)X +3149(dependencies)X +3647(and)X +3798(execu-)X +576 4308(tion)N +748(order)X +967(are)X +1108(indicated)X +1466(in)X +1569(an)X +1686(analogous)X +2076(manner)X +2373(within)X +2632(that)X +2798(component.)X +3267(Two)X +3461(other)X +3675(constructs)X +576 4420(termed)N +3 f +862(terminate)X +1 f +1269(and)X +3 f +1438(waitprocess)X +1 f +1919(are)X +2068(also)X +2252(provided.)X +2629(Both)X +2843(take)X +3032(a)X +3113(component)X +3547(name)X +3780(and)X +3949(an)X +576 4532(instance)N +894(number)X +1192(\(or)X +1323(0)X +1395(to)X +1492(mean)X +1711(all)X +1828(instances\))X +2208(as)X +2309(arguments;)X +2729(the)X +2865(\256rst)X +3030(aborts)X +3273(the)X +3409(process)X +3700(while)X +3924(the)X +576 4644(second)N +842(blocks)X +1094(the)X +1224(caller)X +1442(until)X +1627(the)X +1757(process)X +2042(completes.)X +3 f +576 4980(2.2.)N +752(Data)X +954(Transfer)X +1308(and)X +1472(Barrier)X +1778(Synchronization)X +1 f +776 5232(Inter-process)N +1258(communication)X +1832(via)X +1964(message)X +2286(passing)X +2574(is)X +2657(one)X +2808(of)X +2905(the)X +3037(basic)X +3242(facilities)X +3572(supported)X +3944(by)X +3 f +9 s +576 5344(PVM)N +1 f +11 s +740(.)X +792(In)X +895(the)X +1033(interest)X +1323(of)X +1426(portability)X +1825(and)X +1982(wide)X +2183 0.2452(applicability,)AX +2678(the)X +2816(primitives)X +3205(to)X +3303(accomplish)X +3734(message)X +576 5456(transfer)N +872(have)X +1066(been)X +1260(derived)X +1552(from)X +1751(existing)X +2059 0.2500(implementations)AX +2677(\(e.g)X +2839([9]\),)X +3020(including)X +3382(those)X +3597(described)X +3963(in)X +576 5568([3].)N +725(Certain)X +1010(aspects,)X +1311(however,)X +1660(are)X +1792(necessarily)X +2208(different;)X +2561(primary)X +2865(among)X +3130(them)X +3331(is)X +3414(addressing.)X +3836(Since)X +576 5680(the)N +712(physical)X +1035(location)X +1349(of)X +1451(processes)X +1816(is)X +1904(deliberately)X +2350(transparent)X +2770(to)X +2868(user)X +3043(programs,)X +3426(message)X +3753(destina-)X +576 5792(tions)N +783(are)X +925(identi\256ed)X +1294(by)X +1417(a)X +1491({component)X +1960(name,)X +2208(instance)X +2532(number})X +2878(pair.)X +3071(Furthermore,)X +3567(owing)X +3821(to)X +3924(the)X + +7 p +%%Page: 7 7 +11 s 11 xH 0 xS 1 f +2231 400(-)N +2282(7)X +2348(-)X +576 688(heterogeneous)N +1108(nature)X +1352(of)X +1449(the)X +1582(underlying)X +1989(hardware)X +2340(that)X +3 f +9 s +2494(PVM)X +1 f +11 s +2683(executes)X +3011(upon,)X +3234(it)X +3309(is)X +3393(necessary)X +3759(for)X +3886(user)X +576 800(programs)N +935(to)X +1031(send)X +1219(and)X +1373(receive)X +1654(typed)X +1877(data)X +2051(in)X +2147(a)X +2213(machine)X +2538(independent)X +2995(form.)X +3214(To)X +3338(enable)X +3594(this,)X +3770(a)X +3835(set)X +3959(of)X +576 912(conversion)N +989(routines)X +1300(has)X +1444(been)X +1637(provided)X +1977(\320)X +2092(user)X +2265(programs)X +2624(invoke)X +2892(these)X +3101(routines)X +3413(to)X +3510(construct)X +3861(mes-)X +576 1024(sage)N +754(buffers)X +1024(and)X +1173(to)X +1264(retrieve)X +1555(data)X +1724(values)X +1971(from)X +2164(incoming)X +2520(messages.)X +776 1276(In)N +871(keeping)X +1172(with)X +1351(popular)X +1642(message)X +1962(passing)X +2249(mechanisms,)X +2730(the)X +3 f +9 s +2857(PVM)X +11 s +3044(send)X +1 f +3238(and)X +3 f +3388(receive)X +1 f +3675(constructs)X +576 1388(incorporate)N +1003(a)X +1068("type")X +1318(argument.)X +1699(This)X +1882(is)X +1967(the)X +2101(only)X +2284(argument)X +2642(to)X +3 f +2736(receive)X +1 f +3000(,)X +3047(while)X +3 f +3268(send)X +1 f +3464(requires)X +3772(a)X +3836(desti-)X +576 1500(nation)N +827(component)X +1249(name)X +1470(and)X +1628(instance)X +1948(number)X +2248(as)X +2352(additional)X +2737(arguments.)X +3157(The)X +3325(type)X +3508(parameter)X +3891(per-)X +576 1612(mits)N +759(the)X +897(selective)X +1236(reception)X +1594(of)X +1697(messages)X +2059(and)X +2216(has)X +2363(been)X +2559(found)X +2794(to)X +2892(be)X +3004(extremely)X +3386(useful)X +3630(in)X +3728(practical)X +576 1724(applications.)N +1053(It)X +1135(should)X +1398(be)X +1509(noted)X +1733(that)X +1894(neither)X +2167(the)X +2303(data)X +2478(buffer)X +2720(itself)X +2925(nor)X +3071(its)X +3184(length)X +3434(appear)X +3697(explicitly)X +576 1836(as)N +684(arguments)X +1086(\320)X +1209(owing)X +1464(to)X +1568(data)X +1749(representation)X +2282(and)X +2443(size)X +2614(differences)X +3038(on)X +3160(different)X +3497(machines,)X +3886(user)X +576 1948(programs)N +940(should)X +1207(only)X +1396(access)X +1652(messages)X +2016(using)X +2239(the)X +2380(conversion)X +2799(routines.)X +3138(Shown)X +3415(in)X +3517(Figure)X +3780(3)X +3857(is)X +3949(an)X +576 2060(example)N +897(of)X +992(data)X +1161(transfer)X +1451(between)X +1766(two)X +1920(component)X +2334(processes.)X +8 f +735 2220(/*)N +894(Sending)X +1318(Process)X +1742(*/)X +735 2332 0.1969(/*-----------------*/)AN +735 2444(initsend\(\);)N +2537(/*)X +2696(Initialize)X +3279(send)X +3544(buffer)X +3915(*/)X +735 2556(putstring\("The)N +1530(square)X +1901(root)X +2166(of)X +2325("\);)X +2537(/*)X +2696(Store)X +3014(values)X +3385(in)X +3915(*/)X +735 2668(putint\(2\);)N +2537(/*)X +2696(machine)X +3120(independent)X +3915(*/)X +735 2780(putstring\("is)N +1477("\);)X +2537(/*)X +2696(form)X +3915(*/)X +735 2892(putfloat\(1.414\);)N +735 3004 0.1964(send\("receiver",4,99\);)AN +2537(/*)X +2696(Instance)X +3173(4;)X +3332(type)X +3597(99)X +3915(*/)X +735 3228(/*)N +894(Receiving)X +1424(Process)X +1848(*/)X +735 3340 0.1960(/*-------------------*/)AN +735 3452(char)N +1000 0.1992(msg1[32],msg2[4];)AX +735 3564(int)N +947(num;)X +1212(float)X +1530(sqnum;)X +735 3676(recv\(99\);)N +2537(/*)X +2696(Receive)X +3120(msg)X +3332(of)X +3491(type)X +3756(99)X +3915(*/)X +735 3788(getstring\(msg1\);)N +2537(/*)X +2696(Extract)X +3120(values)X +3491(in)X +3915(*/)X +735 3900(getint\(&num\);)N +2537(/*)X +2696(a)X +2802(machine)X +3226(specific)X +3915(*/)X +735 4012(getstring\(msg2\);)N +2537(/*)X +2696(manner)X +3915(*/)X +735 4124 0.1992(getfloat\(&sqnum\);)AN +1 f +1667 4396(Figure)N +1919(3)X +1985(:)X +2032(User)X +2219(process)X +2504(data)X +2673(transfer)X +776 4760(In)N +883(order)X +1102(for)X +1238(a)X +1311(receiving)X +1673(process)X +1970(to)X +2073(obtain)X +2328(additional)X +2716(information)X +3167(about)X +3398(the)X +3541(most)X +3748(recently)X +576 4872(received)N +901(message,)X +1248(the)X +3 f +1383(recvinfo)X +1 f +1718(construct)X +2068(is)X +2154(provided;)X +2519(this)X +2674(returns)X +2944(the)X +3078(name)X +3295(and)X +3448(instance)X +3763(number)X +576 4984(of)N +672(the)X +803(sending)X +1100(process)X +1386(and)X +1536(the)X +1667(message)X +1988(length.)X +2276(In)X +2372(addition,)X +2707(two)X +2862(variants)X +3164(of)X +3261(the)X +3 f +3393(recv)X +1 f +3578(construct)X +3925(are)X +576 5096(provided.)N +936(The)X +1097(\256rst,)X +3 f +1280(recv1)X +1 f +1485(,)X +1531(permits)X +1820(the)X +1952(user)X +2122(to)X +2215(specify)X +2493(the)X +2625(maximum)X +3008(number)X +3301(of)X +3398(messages)X +3754(of)X +3851(other)X +576 5208(types)N +790(that)X +951(may)X +1131(arrive)X +1364(in)X +1461(the)X +1597(interim)X +1882(\(i.e.)X +2048(while)X +2273(waiting)X +2567(for)X +2698(a)X +2766(message)X +3093(of)X +3195(the)X +3332(speci\256ed)X +3674(type\).)X +3906(If)X +3993(a)X +576 5320(message)N +902(of)X +1003(the)X +1138(anticipated)X +1553(type)X +1732(does)X +1920(not)X +2060(arrive)X +2292(within)X +2545(this)X +2700(window,)X +3032(an)X +3142(error)X +3339(value)X +3557(is)X +3643(returned)X +3963(to)X +576 5432(the)N +731(program,)X +1098(thus)X +1292(enabling)X +1643(the)X +1798(detection)X +2169(of)X +2289(and)X +2463(possible)X +2799(recovery)X +3154(from)X +3373(incorrect)X +3734(program)X +576 5544(behavior)N +948(or)X +1085(unacceptable)X +1609(levels)X +1878(of)X +2014(asynchrony.)X +2504(The)X +2704(second)X +3011(variant,)X +3 f +3341(recv2)X +1 f +3546(,)X +3631(allows)X +3924(the)X +576 5656(speci\256cation)N +1045(of)X +1141(a)X +1203(timeout)X +1497(value)X +1711(and)X +1861(is)X +1943(valuable)X +2265(in)X +2357(preventing)X +2757(certain)X +3020(forms)X +3248(of)X +3344(deadlock)X +3686(as)X +3783(well)X +3959(as)X +576 5768(in)N +670(user-level)X +1042(detection)X +1391(of)X +1489(failed)X +1715(components.)X +2188(Also)X +2379(provided)X +2717(is)X +2801(the)X +3 f +2934(broadcast)X +1 f +3330(primitive)X +3680(that)X +3837(sends)X + +8 p +%%Page: 8 8 +11 s 11 xH 0 xS 1 f +2231 400(-)N +2282(8)X +2348(-)X +576 688(a)N +637(message)X +957(to)X +1048(all)X +1159(instances)X +1504(of)X +1599(a)X +1660(speci\256ed)X +1995(component.)X +776 940(Synchronization)N +1377(via)X +1508(barriers)X +1799(is)X +1881(a)X +1944(common)X +2277(operation)X +2634(in)X +2727(many)X +2947(applications.)X +3442(Under)X +3 f +9 s +3681(PVM)X +1 f +11 s +3845(,)X +3891(bar-)X +576 1052(rier)N +725(synchronization)X +1315(is)X +1401(accomplished)X +1913(using)X +2131(the)X +3 f +2266(barrier)X +1 f +2567(construct.)X +2939(This)X +3122(construct)X +3471(takes)X +3678(an)X +3787(integer)X +576 1164(argument;)N +975(an)X +1099(instance)X +1429(of)X +1543(a)X +1623(component)X +2056(invoking)X +2411(this)X +2581(construct)X +2946(will)X +3126(block)X +3364(until)X +3569(the)X +3719(speci\256ed)X +576 1276(number)N +870(of)X +968(instances)X +1316(of)X +1414(the)X +1547(component)X +1963(also)X +2129(arrive)X +2358(at)X +2446(the)X +2578(barrier.)X +2858(For)X +3004(example,)X +3349(to)X +3442(measure)X +3759(the)X +3891(per-)X +576 1388(formance)N +938(of)X +1041(algorithm)X +1415(sections,)X +1751(participating)X +2228(components)X +2684(may)X +2866(execute)X +3165(the)X +3304(following)X +3678(section)X +3959(of)X +576 1500(code:)N +8 f +841 1772(.)N +947(.)X +1053(.)X +841 1884(barrier\(k\);)N +1795(/*)X +1954(There)X +2272(are)X +2484(k)X +2590(instances)X +3120(executing)X +3650(*/)X +841 1996(/*)N +1000(Get)X +1212(start)X +1530(time)X +1795(*/)X +841 2108(/*)N +1000(Perform)X +1424(computations)X +2113(*/)X +841 2220(/*)N +1000(Get)X +1212(end)X +1424(time)X +1689(*/)X +841 2332(barrier\(k\);)N +841 2444(/*)N +1000(Compute)X +1424(global)X +1795(maximum)X +2219(of)X +2378(\(end)X +2643(time)X +2908(-)X +3014(start)X +3332(time\))X +3650(*/)X +1 f +576 2632(When)N +808(the)X +938(barrier)X +1194(construct)X +1539(has)X +1678(the)X +1809(above)X +2042(semantics)X +2413(however,)X +2760(it)X +2833(is)X +2915(possible)X +3227(that)X +3383(different)X +3709(instances)X +576 2744(invoke)N +845(the)X +3 f +982(barrier)X +1 f +1285(construct)X +1636(with)X +1821(different)X +2152(arguments.)X +2569(Any)X +2748(such)X +2937(con\257icts)X +3264(are)X +3399(resolved)X +3725(by)X +3841(using)X +576 2856(the)N +708(maximum)X +1091(speci\256ed)X +1428(number)X +1721(as)X +1818(the)X +1950(barrier)X +2208(count.)X +2472(The)X +3 f +9 s +2629(PVM)X +1 f +11 s +2817(system)X +3086(also)X +3252(attempts)X +3576(to)X +3669(detect)X +3905(and)X +576 2968(correct)N +849(barrier)X +1112(deadlocks)X +1493(by)X +1610(notifying)X +1963(invoking)X +2306(processes)X +2671(if)X +2754(some)X +2969(instances)X +3321(of)X +3423(a)X +3490(component)X +3910(ter-)X +576 3080(minate)N +850(before)X +1107(they)X +1292(reach)X +1515(a)X +1587(barrier,)X +1876(and)X +2036(the)X +2177(residual)X +2489(number)X +2791(of)X +2897(instances)X +3253(cannot)X +3521(form)X +3725(a)X +3798(barrier)X +576 3192(quorum.)N +897(In)X +995(such)X +1181(situations,)X +1567(live)X +1725(processes)X +2086(return)X +2321(from)X +2517(a)X +3 f +2581(barrier)X +1 f +2880(call)X +3032(with)X +3213(a)X +3276(negative)X +3599(result)X +3819(value.)X +576 3304(In)N +673(addition)X +987(to)X +1080(barriers,)X +1394(or)X +1491(as)X +1588(an)X +1695(alternative,)X +2114(the)X +3 f +2247(waituntil)X +1 f +2610(construct)X +2958(is)X +3042(also)X +3209(provided)X +3547(as)X +3645(a)X +3709(means)X +3959(of)X +576 3416(synchronization.)N +1201(This)X +1398(construct)X +1760(\(suggested)X +2175(in)X +2283([10]\))X +2497(takes)X +2717(an)X +2839(event)X +3069(name)X +3299(as)X +3411(an)X +3533(argument)X +3905(and)X +576 3528(blocks)N +834(until)X +1026(another)X +1319(process)X +1611(indicates)X +1954(the)X +2091(occurrence)X +2505(of)X +2607(that)X +2769(event)X +2989(by)X +3106(using)X +3326(the)X +3 f +3463(ready)X +1 f +3707(primitive)X +576 3640(mentioned)N +971(earlier.)X +3 f +576 3976(2.3.)N +752(Shared)X +1043(Memory)X +1387(and)X +1551(Mutual)X +1852(Exclusion)X +1 f +776 4228(The)N +945(use)X +1094(of)X +1199(shared)X +1461(memory)X +1788(to)X +1890(synchronize)X +2348(and)X +2508(communicate)X +3017(between)X +3343(processes)X +3712(is)X +3804(a)X +3876(con-)X +576 4340(venient)N +865(and)X +1020(well)X +1200(understood)X +1619(paradigm,)X +2002(and)X +2157(the)X +3 f +9 s +2289(PVM)X +1 f +11 s +2481(system)X +2754(provides)X +3085(such)X +3274(an)X +3385(interface)X +3721(for)X +3851(algo-)X +576 4452(rithms)N +831(that)X +993(are)X +1129(best)X +1300(expressed)X +1675(in)X +1773(these)X +1983(terms.)X +2230(This)X +2416(facility,)X +2718(however,)X +3071(should)X +3335(be)X +3448(used)X +3639(judiciously)X +576 4564(\320)N +693(since)X +903(shared)X +1161(memory)X +1484(is)X +1572(emulated)X +1925(by)X +3 f +9 s +2038(PVM)X +1 f +11 s +2231(on)X +2347(distributed)X +2753(memory)X +3075(architectures,)X +3575(some)X +3789(perfor-)X +576 4676(mance)N +832(degradation)X +1274(is)X +1359(inevitable)X +1735(when)X +1952(the)X +2087(granularity)X +2501(of)X +2601(access)X +2852(is)X +2938(very)X +3121(\256ne.)X +3302(Nevertheless,)X +3805(such)X +3993(a)X +576 4788(feature)N +854(is)X +947(useful)X +1196(and)X +1357(valuable.)X +1712(For)X +1868(example,)X +2223(when)X +2447(using)X +2672(the)X +2814("bag)X +3011(of)X +3117(tasks")X +3362(and)X +3522("worker)X +3839(pool")X +576 4900(approach,)N +945(the)X +1078(shared)X +1332(memory)X +1651(model)X +1897(permits)X +2188(greater)X +2458(control,)X +2756(increased)X +3114(overall)X +3385(throughput,)X +3820(and)X +3973(is)X +576 5012(affected)N +885(less)X +1042(by)X +1155(load)X +1332(imbalances,)X +1776(provided)X +2114(the)X +2247(tasks)X +2448(are)X +2580(of)X +2678(suf\256ciently)X +3100(large)X +3301(size.)X +3485(Since)X +3 f +9 s +3702(PVM)X +1 f +11 s +3891(per-)X +576 5124(mits)N +755(each)X +942(worker)X +1216(in)X +1311(the)X +1445(pool)X +1628(to)X +1723(run)X +1866(on)X +1981(different)X +2311(architectures,)X +2810(the)X +2945(individual)X +3331(worker)X +3606(components)X +576 5236(\(or)N +710(groups)X +981(thereof\))X +1291(may)X +1475(be)X +1590(written)X +1872(to)X +2 f +1973(internally)X +1 f +2348(use)X +2496(either)X +2728(message)X +3057(passing)X +3352(or)X +3456(shared)X +3716(memory.)X +576 5348(Section)N +873(5)X +949(describes)X +1308(an)X +1423(experiment)X +1852(where)X +2098(this)X +2258(facility)X +2541(was)X +2709(successfully)X +3172(used)X +3366(to)X +3468(enable)X +3731(a)X +3803(shared)X +576 5460(memory)N +892(multiprocessor)X +1438(to)X +1529(cooperate)X +1893(with)X +2072(a)X +2133(hypercube)X +2521(in)X +2612(the)X +2742(solution)X +3049(of)X +3144(an)X +3249(application)X +3664(problem.)X +776 5712(The)N +951(shared)X +1218(memory)X +1550(primitives)X +1947(provided)X +2298(are)X +2444(modeled)X +2787(once)X +2992(again)X +3222(after)X +3422(popular,)X +3752(existing)X +576 5824 0.2333(implementations.)AN +1238(A)X +1329(shared)X +1585(memory)X +1906(segment)X +2227(is)X +2313(\256rst)X +2477(allocated)X +2823(by)X +2938(invoking)X +3279(the)X +3 f +3414(shmget)X +1 f +3709(construct)X + +9 p +%%Page: 9 9 +11 s 11 xH 0 xS 1 f +2231 400(-)N +2282(9)X +2348(-)X +576 688(that)N +731(takes)X +934(a)X +995(string)X +1218(valued)X +1476(identi\256er)X +1818(and)X +1968(a)X +2030(segment)X +2347(size)X +2507(in)X +2599(bytes.)X +2852(To)X +2973(acquire)X +3255(a)X +3317(shared)X +3569(memory)X +3886(seg-)X +576 800(ment)N +783(for)X +915(use,)X +1084(a)X +1153(user)X +1329(process)X +1622(invokes)X +1926(the)X +3 f +2064(shmat)X +1 f +2323(construct,)X +2698(specifying)X +3094(the)X +3231(segment)X +3554(identi\256er,)X +3924(the)X +576 912(address)N +869(within)X +1125(the)X +1263(process)X +1556(at)X +1650(which)X +1895(the)X +2033(segment)X +2357(is)X +2446(to)X +2546(be)X +2660(mapped,)X +2992(a)X +3062(\257ag)X +3225(indicating)X +3610(whether)X +3924(the)X +576 1024(segment)N +899(is)X +987(to)X +1085(be)X +1197(mapped)X +1505(read-only)X +1871(or)X +1973(read-write,)X +2385(and)X +2541(a)X +2609(timeout)X +2909(value.)X +3150(This)X +3335(construct)X +3686 0.4306(implicitly)AX +576 1136(incorporates)N +1033(a)X +1094(lock)X +1268(operation;)X +1648(if)X +1724(mutually)X +2061(exclusive)X +2416(access)X +2662(to)X +2754(the)X +2885(segment)X +3202(cannot)X +3460(be)X +3566(provided,)X +3924(the)X +576 1248(invoking)N +912(process)X +1197(is)X +1278(suspended)X +1666(\320)X +1776(for)X +1900(a)X +1961(period)X +2208(not)X +2343(to)X +2434(exceed)X +2700(the)X +2830(speci\256ed)X +3165(timeout)X +3458(value.)X +776 1500(The)N +950(attach)X +1198(operation)X +1568(described)X +1942(above)X +2189(maps)X +2412(a)X +2488(contiguous,)X +2934(untyped)X +3255(block)X +3488(of)X +3598(bytes)X +3822(at)X +3924(the)X +576 1612(speci\256ed)N +914(address.)X +1224(In)X +1322(most)X +1519(situations)X +1883(however,)X +2232(shared)X +2486(memory)X +2805(segments)X +3158(will)X +3321(be)X +3429(used)X +3615(to)X +3709(store)X +3905(and)X +576 1724(manipulate)N +998(typed)X +1223(data.)X +1421(In)X +1523(order)X +1737(to)X +1835(permit)X +2095(this)X +2252(among)X +2522(dissimilar)X +2901(machines,)X +3286(typed)X +3512(variants)X +3821(of)X +3924(the)X +576 1836(attach)N +813(construct)X +1162(are)X +1295(provided.)X +1656(For)X +1804(example,)X +2151(the)X +3 f +2285(shmatint)X +1 f +2643(construct)X +2991(takes)X +3197(an)X +3305(integer)X +3575(pointer)X +3850(as)X +3948(its)X +576 1948(second)N +843(argument,)X +1221(while)X +1440(the)X +3 f +1572(shmat\257oat)X +1 f +1991(variant)X +2260(is)X +2343(used)X +2528(for)X +2654(shared)X +2907(memory)X +3225(regions)X +3508(that)X +3665(hold)X +3846(\257oat-)X +576 2060(ing)N +725(point)X +943(values.)X +1248(\(It)X +1367(should)X +1637(be)X +1755(noted)X +1986(that)X +2154(typed)X +2385(data)X +2567(transfer)X +2870(between)X +3198(dissimilar)X +3582(architectures)X +576 2172(could)N +807(lead)X +989(to)X +1093(loss)X +1266(of)X +1375(precision)X +1734(or)X +1843(to)X +1948(truncation)X +2342(owing)X +2598(to)X +2703(wordsize)X +3056(differences.)X +3526(Both)X +3734(message)X +576 2284(passing)N +865(and)X +1017(shared)X +1271(memory)X +1590(mechanisms)X +2051(are)X +2183(subject)X +2458(to)X +2552(this)X +2705(drawback.)X +3115(The)X +3 f +9 s +3273(PVM)X +1 f +11 s +3462(system)X +3732(attempts)X +576 2396(to)N +671(minimize)X +1032(this)X +1186(by)X +1300(utilizing)X +1623(the)X +1758(largest)X +2020(size)X +2184(possible)X +2500(for)X +2629(typed)X +2852(data)X +3026(values.\))X +3351(When)X +3588(a)X +3654(process)X +3944(no)X +576 2508(longer)N +836(needs)X +1071(exclusive)X +1439(access)X +1698(to)X +1802(a)X +1876(region,)X +2158(it)X +2243(invokes)X +2552(the)X +3 f +2694(shmdt)X +1 f +2962(construct)X +3319(\(or)X +3455(a)X +3528(typed)X +3758(variant\))X +576 2620(whereupon)N +993(the)X +1128(lock)X +1307(is)X +1393(released)X +1708(and)X +1862(the)X +1997(region)X +2249(unmapped.)X +2666(Finally,)X +2967(the)X +3 f +3103(shmfree)X +1 f +3433(construct)X +3784(is)X +3871(used)X +576 2732(to)N +670(deallocate)X +1053(a)X +1117(segment)X +1436(of)X +1534(shared)X +1788(memory)X +2107(when)X +2322(it)X +2397(is)X +2481(no)X +2594(longer)X +2844(required.)X +3183(Shown)X +3451(in)X +3544(Figure)X +3798(4)X +3866(is)X +3949(an)X +576 2844(example)N +897(of)X +992(the)X +1122(use)X +1261(of)X +1356(these)X +1559(constructs)X +1938(to)X +2029(pass)X +2202(an)X +2307(array)X +2509(of)X +2604(real)X +2758(numbers)X +3083(between)X +3398(two)X +3552(processes.)X +8 f +735 3116(/*)N +894(Process)X +1318(A)X +1424(*/)X +735 3228(/*-----------*/)N +735 3340(if)N +894 0.1964(\(shmget\("matrx",1024\)\))AX +2113(error\(\);/*)X +2696(Allocation)X +3279(failure)X +3862(*/)X +735 3452(while)N +2537(/*)X +2696(Try)X +2908(to)X +3067(lock)X +3332(&)X +3438(map)X +3650(seg)X +3862(*/)X +894 3564 0.1935(\(shmatfloat\("matrx",fp,"RW",5\)\);)AN +735 3676(for)N +947(\(i=0;i<256;i++\))X +1795(*fp++)X +2113(=)X +2219(a[i];)X +2537(/*)X +2696(Fill)X +2961(in)X +3120(shmem)X +3438(segment)X +3862(*/)X +735 3788 0.1974(shmdtfloat\("matrx"\);)AN +2537(/*)X +2696(Unlock)X +3067(&)X +3173(unmap)X +3491(region)X +3862(*/)X +735 4012(/*)N +894(Process)X +1318(B)X +1424(*/)X +735 4124(/*-----------*/)N +735 4236(while)N +2537(/*)X +2696(Lock)X +2961(&)X +3067(map;)X +3332(note:reader*/)X +894 4348 0.1934(\(shmatfloat\("matrx",fp,"R",5\)\);/*)AN +2696(may)X +2908(lock)X +3173(before)X +3544(writer)X +3915(*/)X +735 4460(for)N +947(\(i=0;i<256;i++\))X +1795(a[i])X +2060(=)X +2166(*fp++;)X +2537(/*)X +2696(Read)X +2961(out)X +3173(values)X +3915(*/)X +735 4572 0.1974(shmdtfloat\("matrx"\);)AN +2537(/*)X +2696(Unlock)X +3067(&)X +3173(unmap)X +3491(region)X +3915(*/)X +735 4684 0.1992(shmfree\("matrx"\);)AN +2537(/*)X +2696(Deallocate)X +3279(mem)X +3491(segment)X +3915(*/)X +1 f +1581 4844(Figure)N +1833(4)X +1899(:)X +1946(Use)X +2104(of)X +2199(shared)X +2450(memory)X +2766(for)X +2890(IPC)X +776 5096(While)N +1014(shared)X +1265(memory)X +1581(is)X +1662(perhaps)X +1957(the)X +2087(most)X +2281(common)X +2612(resource)X +2931(that)X +3086(processes)X +3445(require)X +3717(mutually)X +576 5208(exclusive)N +957(access)X +1229(to,)X +1368(it)X +1466(is)X +1573(possible)X +1910(that)X +2091(the)X +3 f +9 s +2243(PVM)X +1 f +11 s +2455(environment)X +2949(contains)X +3291(other)X +3520(resources)X +3899(that)X +576 5320(processes)N +946(must)X +1152(access)X +1410(in)X +1513(a)X +1586(similar)X +1866(manner.)X +2186(To)X +2318(accommodate)X +2842(such)X +3037(requirements,)X +3553(a)X +3626(generalized)X +576 5432(locking)N +864(facility)X +1138(is)X +1220(also)X +1385(provided.)X +1743(The)X +3 f +1903(lock)X +1 f +2082(construct)X +2427(permits)X +2714(the)X +2844(logical)X +3107(locking)X +3394(of)X +3489(an)X +3594(entity)X +3818(that)X +3973(is)X +576 5544(named)N +840(by)X +957(a)X +1025(string)X +1255(argument;)X +1642(the)X +3 f +9 s +1776(PVM)X +1 f +11 s +1970(system)X +2245(blocks)X +2505(other)X +2716(processes)X +3082(wishing)X +3391(to)X +3490(lock)X +3672(this)X +3830(entity)X +576 5656(until)N +769(the)X +907(possessor)X +1273(invokes)X +1577(the)X +3 f +1715(unlock)X +1 f +2000(construct.)X +2397(For)X +2549(example,)X +2899(different)X +3231(components)X +3686(of)X +3788(a)X +3856(large)X +576 5768(application)N +996(may)X +1175(wish)X +1368(to)X +1464(output)X +1717(results)X +1974(periodically)X +2424(to)X +2521(a)X +2588(user)X +2762(terminal.)X +3107(To)X +3233(avoid)X +3457(interference)X +3905(and)X + +10 p +%%Page: 10 10 +11 s 11 xH 0 xS 1 f +2209 400(-)N +2260(10)X +2370(-)X +576 688(to)N +670(distinguish)X +1083(the)X +1216(source)X +1470(of)X +1568(the)X +1701(output,)X +1974(components)X +2425(may)X +2602(adopt)X +2823(a)X +2887(convention)X +3303(that)X +3460(requires)X +3767(locking)X +576 800(")N +7 f +612(terminal)X +1 f +1036(")X +1100(before)X +1352(printing)X +1660(messages)X +2021(or)X +2123(results.)X +2404(Another)X +2721(situation)X +3055(where)X +3298(such)X +3488(a)X +3556(facility)X +3836(could)X +576 912(be)N +685(useful)X +926(may)X +1104(be)X +1213(found)X +1444(in)X +1539(the)X +1673(shared)X +1928(memory)X +2248(example)X +2573(in)X +2668(Figure)X +2924(4.)X +3016(In)X +3115(that)X +3274(example,)X +3621(it)X +3697(is)X +3782(easy)X +3963(to)X +576 1024(see)N +714(that)X +873(the)X +1007(processes)X +1369(may)X +1547(access)X +1797(the)X +1931(shared)X +2186(memory)X +2506(segment)X +2826(in)X +2922(an)X +3032(incorrect)X +2 f +3372(order)X +1 f +3594(even)X +3787(though)X +576 1136(each)N +767(will)X +935(have)X +1131(exclusive)X +1494(access)X +1748(to)X +1847(it.)X +1949(A)X +2042(possible)X +2361(recti\256cation)X +2813(of)X +2915(this)X +3072(situation)X +3406(is)X +3494(to)X +3592(use)X +3738(the)X +3 f +3875(lock)X +1 f +576 1248(construct)N +925(as)X +1025(shown)X +1281(in)X +1377(Figure)X +1634(5;)X +1730(however,)X +2081(in)X +2177(practice)X +2483(it)X +2560(is)X +2646(more)X +2854(likely)X +3083(that)X +3243(a)X +3309(transmitted)X +3734(message)X +576 1360(or)N +671(the)X +3 f +801(waituntil)X +1 f +1161(facility)X +1434(will)X +1594(be)X +1699(used)X +1882(to)X +1973(resolve)X +2249(such)X +2432(situations.)X +8 f +735 1632(/*)N +894(Process)X +1318(A)X +1424(*/)X +735 1744(/*-----------*/)N +735 1856 0.1969(lock\("fillmatrix",5\);)AN +735 1968(/*)N +894(Allocate,)X +1424(attach,)X +1848(fill,)X +2166(and)X +2378(detach)X +2749(shared)X +3120(mem)X +3332(segment.)X +3809(*/)X +735 2080 0.1969(unlock\("fillmatrix"\);)AN +735 2304(/*)N +894(Process)X +1318(B)X +1424(*/)X +735 2416(/*-----------*/)N +735 2528(loop:)N +894 2640 0.1969(lock\("fillmatrix",5\);)AN +894 2752(if)N +1053(\(shmatfloat\(...\))X +1954(==)X +2113 0.1974(SEGMENT_NONEXISTENT\))AX +3226({)X +1053 2864 0.1969(unlock\("fillmatrix"\);)AN +1053 2976(sleep\(1\);)N +1053 3088(goto)N +1318(loop;)X +894 3200(})N +735 3312(/*)N +894(Read)X +1159(values)X +1530(out)X +1742(of)X +1901(shared)X +2272(mem)X +2484(segment,)X +2961(detach,)X +3385(&)X +3491(free)X +3756(*/)X +1 f +1651 3472(Figure)N +1903(5)X +1969(:)X +2016(Use)X +2174(of)X +2269(the)X +7 f +2399(lock)X +1 f +2633(construct)X +776 3836(It)N +855(should)X +1115(be)X +1223(noted)X +1444(that)X +1602(the)X +3 f +1735(lock)X +1 f +1917(construct)X +2265(is)X +2350(intended)X +2680(in)X +3 f +9 s +2771(PVM)X +1 f +11 s +2961(for)X +3089(obtaining)X +3449(exclusive)X +3808(access)X +576 3948(to)N +674(resources)X +1033(at)X +1125(a)X +1192(large-grained)X +1689(level,)X +1911(as)X +2012(opposed)X +2333(to)X +2430(loop)X +2615(level)X +2815(locking)X +3108(of)X +3209(shared)X +3466(variables)X +3812(that)X +3973(is)X +576 4060(common)N +908(on)X +1019(shared)X +1271(memory)X +1588(machines.)X +1966(Once)X +2174(again,)X +2410(a)X +2473(component)X +2889(that)X +3046(executes)X +3373(on)X +3485(such)X +3670(a)X +3733(machine)X +576 4172(would)N +833(be)X +953(programmed)X +1440(to)X +1546(use)X +1699(internal)X +2005(locking)X +2306(constructs)X +2699(where)X +2949(appropriate,)X +3408(and)X +3 f +9 s +3567(PVM)X +1 f +11 s +3767(locking)X +576 4284(facilities)N +905(for)X +1032(resource)X +1354(sharing)X +1638(between)X +1956(other)X +2162(components)X +2613(that)X +2771(executed)X +3109(on)X +3222(other)X +3428(architectures.)X +3925(An)X +576 4396(example)N +903(code)X +1097(skeleton)X +1419(depicting)X +1776(this)X +1932(situation)X +2265(on)X +2381(a)X +2447(Sequent)X +2758(shared)X +3014(memory)X +3335(multiprocessor)X +3886([19])X +576 4508(is)N +657(shown)X +908(in)X +999(Figure)X +1251(6.)X +3 f +576 4956(2.4.)N +752(Miscellaneous)X +1303(Facilities)X +1 f +776 5208(In)N +874(addition)X +1189(to)X +1284(the)X +1418(primary)X +1723(constructs)X +2106(described)X +2469(in)X +2564(the)X +2698(preceding)X +3071(sections,)X +3403(a)X +3468(few)X +3625(miscellane-)X +576 5320(ous)N +737(constructs)X +1132(are)X +1277(also)X +1457(provided.)X +1830(The)X +3 f +2005(status)X +1 f +2262(construct)X +2623(takes)X +2842(a)X +2919(component)X +3349(name)X +3578(and)X +3743(instance)X +576 5432(number)N +870(as)X +968(arguments)X +1360(and)X +1512(returns)X +1781(status)X +2007(and)X +2159(location)X +2469(information)X +2911(regarding)X +3274(that)X +3433(component.)X +3895(The)X +3 f +576 5544(entercomp)N +1 f +1000(construct)X +1347(permits)X +1636(dynamic)X +1963(additions)X +2310(to)X +2402(the)X +2533(component)X +2948(description)X +3363(table.)X +3580(The)X +3 f +3740(shmstat)X +1 f +576 5656(construct)N +929(is)X +1018(used)X +1209(to)X +1308(obtain)X +1559(information)X +2007(about)X +2234(active)X +2476(shared)X +2736(memory)X +3061(regions,)X +3373(while)X +3600(the)X +3 f +3739(lockstat)X +1 f +576 5768(primitive)N +935(reports)X +1213(the)X +1355(status)X +1590(of)X +1697(active)X +1942(locks.)X +2184(A)X +2281(complete)X +2639(list)X +2782(of)X +2889(all)X +3012(the)X +3154(user)X +3334(interface)X +3675(constructs)X + +11 p +%%Page: 11 11 +11 s 11 xH 0 xS 1 f +2209 400(-)N +2260(11)X +2370(-)X +8 f +1106 736(.)N +1212(.)X +1318(.)X +1106 848(CALL)N +1371 0.1942(shmatfloat\("A_row1",A,"RW",5\))AX +7 f +1106 960({Lock)N +1424(&)X +1530(map)X +1742(row)X +1954(1)X +2060(of)X +2219(an)X +2 f +2378(external)X +7 f +2720(shared)X +3091(array)X +3409(to)X +3568(A})X +8 f +1106 1072(.)N +1212(.)X +1318(.)X +788 1184(C$DOACROSS)N +1371(SHARE\(A,index\))X +1106 1296(do)N +1265(20)X +1424(i)X +1530(=)X +1636(1,)X +1795(100)X +1106 1408(.)N +1212(.)X +1318(.)X +1106 1520(CALL)N +1371(m_lock)X +7 f +1106 1632({Local,)N +1530(loop)X +1795(level)X +2113(lock)X +2378(to)X +2537(indicate)X +3014(critical)X +3491(section})X +8 f +1106 1744(index)N +1424(=)X +1530(index)X +1848(+)X +1954(1)X +1106 1856(CALL)N +1371(m_unlock)X +1106 1968(.)N +1212(.)X +1318(.)X +788 2080(20)N +1106(continue)X +1106 2192(.)N +1212(.)X +1318(.)X +1106 2304(CALL)N +1371 0.1974(shmdtfloat\("A_row1"\))AX +7 f +1106 2416({Unlock)N +1530(and)X +1742(unmap)X +2060(external)X +2537(shared)X +2908(array})X +8 f +1106 2528(.)N +1212(.)X +1318(.)X +1 f +1173 2688(Figure)N +1425(6:)X +3 f +9 s +1516(PVM)X +1 f +11 s +1702(locking)X +1989(contrasted)X +2373(to)X +2464(machine)X +2785(dependent)X +3169(locking)X +576 2912(along)N +794(with)X +973(their)X +1157(argument)X +1512(lists)X +1677(and)X +1826(a)X +1887(one-line)X +2198(description)X +2612(of)X +2707(each)X +2890(is)X +2971(given)X +3189(in)X +3280(the)X +3410(appendix.)X +3 f +576 3248(3.)N +686(PVM)X +908(System)X +1198(Design)X +1474(and)X +1638(Implementation)X +1 f +776 3500(The)N +3 f +9 s +938(PVM)X +1 f +11 s +1131(support)X +1424(software)X +1756(executes)X +2089(as)X +2192(a)X +2261(user-level)X +2638(process)X +2931(on)X +3049(each)X +3240(host)X +3417(in)X +3516(the)X +3654(participant)X +576 3612(pool.)N +778(An)X +908(initial)X +1139(set)X +1260(of)X +1356(participating)X +1825(hosts)X +2028(is)X +2109(statically)X +2451(identi\256ed;)X +2832(additions)X +3178(or)X +3273(deletions)X +3614(are)X +3743(possible)X +576 3724(during)N +842(operation)X +1212(by)X +1337(means)X +1599(of)X +1709(an)X +1829(administration)X +2377(interface.)X +2744(The)X +3 f +9 s +2914(PVM)X +1 f +11 s +3115(system)X +3397(is)X +3493(designed)X +3843(to)X +3949(be)X +576 3836(implemented)N +1061(in)X +1153(a)X +1215(manner)X +1502(that)X +1658(requires)X +1964(no)X +2075(operating)X +2431(system)X +2699(changes)X +3005(or)X +3101(modi\256cations,)X +3627(and)X +3777(porting)X +576 3948(efforts)N +834(to)X +932(varied)X +1181(operating)X +1544(system)X +1819(environments)X +2329(are)X +2466(minimal.)X +2814(The)X +3 f +9 s +2977(PVM)X +1 f +11 s +3171(support)X +3465(process)X +3758(\(termed)X +2 f +576 4060(pvmd)N +1 f +766(\))X +828(on)X +949(a)X +1021(host)X +1201(is)X +1293(responsible)X +1727(for)X +1862(all)X +1983(application)X +2408(component)X +2832(processes)X +3200(executing)X +3575(on)X +3695(that)X +3860(host;)X +576 4172(however,)N +922(there)X +1120(is)X +1202(no)X +1313(central)X +1576(or)X +1672(master)X +1930(instance)X +2242(of)X +2 f +2338(pvmd)X +1 f +2528(.)X +2573(Control)X +2866(is)X +2948(completely)X +3364(distributed)X +3765(\(by)X +3905(vir-)X +576 4284(tue)N +714(of)X +817(all)X +2 f +936(pvmd)X +1 f +1156(processes)X +1522(possessing)X +1928(global)X +2179(knowledge\))X +2624(in)X +2722(the)X +2859(interest)X +3148(of)X +3250(avoiding)X +3588(performance)X +576 4396(bottlenecks)N +1003(and)X +1155(increasing)X +1542(fault)X +1729(tolerance.)X +2099(The)X +2 f +2261(pvmd)X +1 f +2476(processes)X +2837(are)X +2969(initiated)X +3285(on)X +3398(each)X +3585(participating)X +576 4508(host)N +770(either)X +1018(manually,)X +1416(through)X +1737(the)X +1892(administration)X +2450(interface,)X +2827(or)X +2947(via)X +3102(a)X +3188(machine/OS)X +3670(dependent)X +576 4620(mechanism)N +1004(such)X +1191(as)X +2 f +1290(inetd)X +1 f +1493(in)X +1588(the)X +1723(Unix)X +1926(environment.)X +2443(In)X +2543(this)X +2698(section,)X +2997(the)X +3132(key)X +3286(design)X +3543(aspects)X +3824(of)X +3924(the)X +2 f +576 4732(pvmd)N +1 f +788(software)X +1112(are)X +1241(discussed)X +1600(with)X +1779(an)X +1884(emphasis)X +2234(on)X +2344(the)X +2474(protocol)X +2790(algorithms)X +3190(used.)X +3 f +576 5068(3.1.)N +752(Basic)X +975(Facilities)X +1 f +776 5320(In)N +894(terms)X +1135(of)X +1253(network)X +1586(capabilities,)X +2056(the)X +3 f +9 s +2205(PVM)X +1 f +11 s +2414(system)X +2704(assumes)X +3042(only)X +3244(that)X +3422(unreliable,)X +3842(unse-)X +576 5432(quenced,)N +934(point-to-point)X +1467(data)X +1656(transfer)X +1966(\(but)X +2150(with)X +2349(data)X +2538(integrity\))X +2909(facilities)X +3256(are)X +3405(supported)X +3794(by)X +3924(the)X +576 5544(hardware)N +926(platform)X +1255(on)X +1368(which)X +1608(it)X +1683(executes.)X +2033(The)X +2195(required)X +2513(reliability)X +2883(and)X +3035(sequencing,)X +3478(as)X +3576(well)X +3753(as)X +3851(other)X +576 5656(necessary)N +943(operations)X +1336(such)X +1522(as)X +1620(broadcast,)X +2004(are)X +2136(built)X +2324(into)X +2487(the)X +3 f +9 s +2616(PVM)X +1 f +11 s +2805(system)X +3075(in)X +3169(the)X +3302(interest)X +3587(of)X +3685(ef\256ciency)X +576 5768(and)N +729(portability.)X +1146(While)X +1388(it)X +1464(is)X +1550(true)X +1714(that)X +1874(most)X +2073(operating)X +2433(systems)X +2739(in)X +2835(existence)X +3190(already)X +3476(support)X +3767(reliable)X + +12 p +%%Page: 12 12 +11 s 11 xH 0 xS 1 f +2209 400(-)N +2260(12)X +2370(-)X +576 688(and)N +734(sequenced)X +1131(data)X +1309(delivery,)X +1651(in)X +1751(most)X +1954(cases)X +2170(this)X +2329(is)X +2419(via)X +2558(the)X +2697(use)X +2844(of)X +2947(virtual)X +3208(circuits)X +3498(\320)X +3616(for)X +3748(the)X +3886(pro-)X +576 800(jected)N +816(use)X +962(of)X +3 f +9 s +1060(PVM)X +1 f +11 s +1224(,)X +1275(the)X +1412(overheads)X +1797(and)X +1953(scalability)X +2346 0.3625(limitations)AX +2756(of)X +2859(using)X +3080(such)X +3271(a)X +3340(service)X +3619(directly)X +3919(did)X +576 912(not)N +721(warrant)X +1020(its)X +1135(adoption.)X +1497(In)X +1601(the)X +1740(test)X +1894 0.2500(implementations)AX +2515(of)X +3 f +9 s +2615(PVM)X +1 f +11 s +2779(,)X +2832(the)X +2971(UDP)X +3177([11])X +3354(protocol)X +3679(was)X +3846(used;)X +576 1024(this)N +727(deliberate)X +1098(choice)X +1351(of)X +1447(a)X +1509(simple)X +1768(datagram)X +2119(protocol)X +2437(also)X +2603(permits)X +2892(relatively)X +3250(simple)X +3510(porting)X +3789(or)X +3886(pro-)X +576 1136(tocol)N +775(conversion)X +1183(when)X +3 f +9 s +1391(PVM)X +1 f +11 s +1577(is)X +1658(to)X +1749(be)X +1854(installed)X +2176(under)X +2398(a)X +2459(different)X +2784(operating)X +3139(system)X +3406(environment.)X +776 1388(Across)N +1042(the)X +1173(network,)X +2 f +1506(pvmd)X +1 f +1719(processes)X +2078(communicate)X +2577(using)X +2791(UDP)X +2990(datagrams.)X +3420(The)X +3581("well)X +3793(known)X +576 1500(port")N +777(approach)X +1122(is)X +1203(used)X +1386(for)X +1510(addressing;)X +1933(all)X +2044(incoming)X +2400(messages)X +2754(are)X +2883(received)X +3203(by)X +2 f +3313(pvmd)X +1 f +3525(processes)X +3883(on)X +3993(a)X +576 1612(predetermined)N +1132(port)X +1321(number.)X +1659(For)X +1828(user-process)X +2313(to)X +2429(user-process)X +2914(communication,)X +3533(the)X +3689(following)X +576 1724(scheme)N +887(is)X +993(employed.)X +1410(The)X +1594(\256rst)X +1778(communication)X +2375(instance)X +2710(between)X +3049(any)X +3222(two)X +3400(entities)X +3702(is)X +3807(routed)X +576 1836(through)N +880(the)X +2 f +1018(pvmd)X +1 f +1239(processes)X +1606(on)X +1725(the)X +1864(source)X +2124(and)X +2282(destination)X +2701(machines.)X +3087(Location)X +3432(and)X +3590(port)X +3763(number)X +576 1948(information)N +1032(is)X +1130(appended)X +1506(to)X +1614(this)X +1781(exchange;)X +2177(the)X +3 f +9 s +2320(PVM)X +1 f +11 s +2522(routines)X +2844(\(linked)X +3132(to)X +3239(the)X +3385(user)X +3569(process\))X +3899(that)X +576 2060(implement)N +3 f +981(send)X +1 f +1179(and)X +3 f +1333(recv)X +1 f +1521(cache)X +1748(this)X +1903(information,)X +2369(thus)X +2543(enabling)X +2874(direct)X +3102(communication)X +3679(for)X +3808(subse-)X +576 2172(quent)N +796(exchanges.)X +1230(Local)X +1455(user)X +1625(processes)X +1985(communicate)X +2485(with)X +2 f +2666(pvmd)X +1 f +2880(using)X +3095(the)X +3226(most)X +3421(ef\256cient)X +3733(machine)X +576 2284(dependent)N +970(mechanism)X +1405(available)X +1757(and)X +1917(the)X +2058(development)X +2547(of)X +2653(this)X +2814(mechanism)X +3249(is)X +3341(deemed)X +3648(part)X +3818(of)X +3924(the)X +576 2396(installation)N +995(procedure.)X +1415(However,)X +1783(the)X +1915(generic)X +2198(version)X +2503(of)X +2 f +2600(pvmd)X +1 f +2814(may)X +2990(be)X +3097(adopted;)X +3425(this)X +3577(utilizes)X +3857(UDP)X +576 2508(datagrams)N +961(once)X +1150(again,)X +1386(via)X +1517(the)X +1649(loopback)X +1996(interface)X +2328(if)X +2406(one)X +2557(is)X +2640(available.)X +3005(The)X +2 f +3166(pvmd)X +1 f +3380(process)X +3667(uses)X +3842(a)X +3905(dif-)X +576 2620(ferent,)N +825(predetermined)X +1356(port)X +1520(number)X +1811(for)X +1935(incoming)X +2291(messages)X +2645(from)X +2838(all)X +2949(local)X +3143(user)X +3311(processes.)X +3 f +576 2956(3.2.)N +752(Point-to-Point)X +1307(Data)X +1509(Transfer)X +1 f +776 3208(To)N +896(achieve)X +1187(reliable)X +1474(and)X +1623(sequenced)X +2011(point-to-point)X +2524(communications,)X +3152(the)X +2 f +3282(pvmd)X +1 f +3494(processes)X +3853(use)X +3993(a)X +576 3320(positive)N +892(acknowledgment)X +1530(scheme)X +1829(and)X +1991(an)X +2109(additional)X +2498(header)X +2767(that)X +2935(contains)X +3264(sequence)X +3621(numbers)X +3959(as)X +576 3432(well)N +758(as)X +861(fragmentation)X +1386(and)X +1543(reassembly)X +1969(information.)X +2438(Unacknowledged)X +3083(transmissions)X +3594(are)X +3732(retried)X +3993(a)X +576 3544(parameterized)N +1104(number)X +1402(of)X +1504(times)X +1725(after)X +1915(which)X +2159(the)X +2296(recipient)X +2634(process)X +2926(or)X +3028(processor)X +3393(is)X +3481(presumed)X +3852(to)X +3949(be)X +576 3656(inoperative.)N +1019(The)X +1180(sequence)X +1526(numbers)X +1853(are)X +1984(destination)X +2396(speci\256c)X +2689(and)X +2840(are)X +2971(used)X +3156(by)X +3268(the)X +3400(message)X +3723(recipient)X +576 3768(for)N +716(sequencing)X +1150(as)X +1261(well)X +1451(as)X +1562(for)X +1702(duplicate)X +2064(detection.)X +2448(The)X +2623(header)X +2895(is)X +2992(placed)X +3260(at)X +3362(the)X +3507(end)X +3671(of)X +3781(a)X +3857(UDP)X +576 3880(datagram)N +936(to)X +1037(reduce)X +1303(copying)X +1619(overheads,)X +2029(and)X +2189(single)X +2433(datagram)X +2794(sizes)X +2998(are)X +3138(restricted)X +3499(to)X +3601(the)X +3742(smallest)X +576 3992(MTU)N +824(\(maximum)X +1265(transmission)X +1764(unit\))X +1984(of)X +2109(all)X +2250(participating)X +2749(hosts.)X +3026(When)X +3288(\256rst)X +3477(initiated,)X +2 f +3842(pvmd)X +1 f +576 4104(processes)N +940(determine)X +1321(the)X +1457(protocol)X +1779(speci\256c)X +2076(addresses)X +2440(of)X +2541(all)X +2658(participating)X +3133(hosts)X +3342(and)X +3497(proceed)X +3803(to)X +3901(ser-)X +576 4216(vice)N +745(incoming)X +1101(requests)X +1411(from)X +1604(the)X +1734(network)X +2044(or)X +2139(user)X +2307(processes)X +2665(in)X +2756(an)X +2861(in\256nite)X +3134(loop.)X +776 4468(Each)N +2 f +977(pvmd)X +1 f +1192(process)X +1480(maintains)X +1849(information)X +2292(concerning)X +2709(the)X +2843(location)X +3154(and)X +3307(status)X +3534(of)X +3633(all)X +3748(applica-)X +576 4580(tion)N +742(component)X +1162(processes.)X +1548(A)X +1639(user)X +3 f +1812(send)X +1 f +2010(is)X +2096(addressed)X +2469(to)X +2565(a)X +2631(component)X +3050(name)X +3268(and)X +3422(instance)X +3738(number;)X +576 4692(the)N +712(local)X +2 f +912(pvmd)X +1 f +1130(determines)X +1545(the)X +1681(physical)X +2003(location)X +2316(of)X +2417(that)X +2578(process)X +2869(and)X +3024(forwards)X +3363(the)X +3499(message)X +3826(to)X +3924(the)X +576 4804(remote)N +2 f +849(pvmd)X +1 f +1039(.)X +1089(As)X +1214(described,)X +1601(the)X +1737(user)X +1911(process)X +2202(library)X +2465(performs)X +2810(this)X +2966(translation)X +3367(for)X +3497(the)X +3633(second)X +3905(and)X +576 4916(subsequent)N +1005(messages.)X +1397(The)X +1572(source)X +1839(component)X +2269(name)X +2498(and)X +2663(instance)X +2990(number)X +3297(are)X +3442(appended)X +3817(to)X +3924(the)X +576 5028(message,)N +929(enabling)X +1266(message)X +1597(delivery)X +1919(with)X +2109(an)X +2225(indication)X +2612(of)X +2718(the)X +2859(sender's)X +3183(identity.)X +3508(As)X +3637(mentioned,)X +576 5140(executing)N +958(the)X +3 f +1105(enroll)X +1 f +1365(construct)X +1727(is)X +1825(a)X +1903(precondition)X +2388(to)X +2496(user)X +2682(process)X +2985(participation)X +3472(\320)X +3600(in)X +3709(the)X +3857(UDP)X +576 5252 0.2679(implementation,)AN +1176(this)X +1326(supplies)X +1637(to)X +1728(the)X +1858(local)X +2 f +2052(pvmd)X +1 f +2264(the)X +2394(receiving)X +2744(port)X +2908(number)X +3199(of)X +3294(the)X +3424(user)X +3592(process.)X + +13 p +%%Page: 13 13 +11 s 11 xH 0 xS 1 f +2209 400(-)N +2260(13)X +2370(-)X +3 f +576 688(3.3.)N +752(Message)X +1091(Broadcasting)X +1 f +776 940(Broadcast)N +1161(is)X +1253(a)X +1326(commonly)X +1738(performed)X +2138(operation)X +2505(in)X +2608(the)X +3 f +9 s +2746(PVM)X +1 f +11 s +2944(system,)X +3245(both)X +3436(because)X +3748(applica-)X +576 1052(tions)N +772(desire)X +1006(such)X +1191(a)X +1254(facility)X +1529(and)X +1680(since)X +1885(it)X +1959(is)X +2042(inherent)X +2355(to)X +2448(the)X +2580(completely)X +2997(distributed)X +3399(nature)X +3643(of)X +3740(the)X +3 f +9 s +3868(PVM)X +1 f +11 s +576 1164(support)N +888(software.)X +1261(All)X +2 f +1423(pvmd)X +1 f +1662(processes)X +2047(maintain)X +2406(information)X +2872(regarding)X +3258(all)X +3396(processes,)X +3803(shared)X +576 1276(memory)N +900(segments,)X +1280(and)X +1437(locks,)X +1675(to)X +1774(guard)X +2004(against)X +2284(loss)X +2451(of)X +2553(context)X +2842(and)X +2998(state)X +3189(in)X +3287(the)X +3424(event)X +3644(of)X +3746(failures.)X +576 1388(User)N +779(process)X +1080(broadcasts)X +1489(are)X +1635(\256rst)X +1811(delivered)X +2178(sequentially)X +2644(to)X +2752(local)X +2963(recipient)X +3311(user)X +3496(processes)X +3871(after)X +576 1500(which)N +814(the)X +945(local)X +2 f +1139(pvmd)X +1 f +1351(process)X +1636(broadcasts)X +2029(over)X +2207(the)X +2337(network)X +2647(to)X +2738(all)X +2849(other)X +2 f +3052(pvmd)X +1 f +3264(processes)X +3622(that)X +3777(in)X +3868(turn,)X +576 1612(deliver)N +843(the)X +973(message)X +1293(to)X +1384(their)X +1568(local)X +1762(user)X +1930(process)X +2215(recipients.)X +2602(Although)X +2957(most)X +3151(computing)X +3552(environments)X +576 1724(support)N +865(a)X +929(network)X +1242(broadcast)X +1604(facility,)X +2 f +1902(pvmd)X +1 f +2117(broadcast)X +2479(is)X +2563(implemented)X +3049(in)X +3 f +9 s +3138(PVM)X +1 f +11 s +3326(using)X +3541(point-to-point)X +576 1836(messages)N +948(with)X +1145(recursive)X +1507(doubling.)X +1883(This)X +2080(decision)X +2414(was)X +2590(made)X +2821(in)X +2931(the)X +3080(interest)X +3381(of)X +3495(portability)X +3905(and)X +576 1948(ef\256ciency;)N +974(given)X +1196(that)X +1355(network)X +1669(broadcast)X +2032(is)X +2116(unreliable,)X +2516(acknowledgments)X +3177(are)X +3309(necessary)X +3675(from)X +3871(each)X +576 2060(recipient,)N +937(resulting)X +1277(in)X +2 f +1377(O)X +1 f +1454(\()X +2 f +1483(p)X +1 f +1534(\))X +1594(time)X +1783(\()X +2 f +1812(p)X +1 f +2 f +9 f +1885(+)X +1 f +1955(1)X +2030(sequential)X +2419(steps)X +2626(are)X +2764(to)X +2864(be)X +2978(performed)X +3375(by)X +3494(the)X +3633(originator\),)X +576 2172(while)N +799(recursive)X +1148(doubling)X +1489(broadcast)X +1852(is)X +1937(accomplished)X +2448(in)X +2 f +2543(O)X +1 f +2620(\(log)X +8 s +2762 2189(2)N +11 s +2 f +2823 2172(p)N +1 f +2874(\))X +2929(time,)X +3135(where)X +2 f +3375(p)X +1 f +3445(is)X +3530(the)X +3664(number)X +3959(of)X +576 2284(processors.)N +993(The)X +1155(participating)X +1627(pool)X +1809(of)X +1907(hosts)X +2113(is)X +2197(logically)X +2532(numbered)X +2909(from)X +3105(0)X +3174(to)X +2 f +3268(p)X +9 f +3326(-)X +1 f +3374(1,)X +3466(and)X +3619(the)X +3753(origina-)X +576 2396(tor)N +697(\(or)X +822(root\))X +1016(of)X +1112(the)X +1243(broadcast)X +1603(is)X +1685(part)X +1845(of)X +1941(the)X +2072(broadcast)X +2432(message.)X +2775(There)X +3002(is)X +3083(one)X +2 f +3232(pvmd)X +1 f +3444(process)X +3729(per)X +3863(host,)X +576 2508(which)N +840(represents)X +1223(that)X +1383(processor.)X +1768(Broadcast)X +2147(proceeds)X +2486(in)X +2582("rounds",)X +2943(with)X +3128(the)X +3264(number)X +3561(of)X +3662(processors)X +576 2620(contributing)N +1031(to)X +1123(the)X +1254(broadcast)X +1614(effort)X +1832(doubling)X +2169(in)X +2261(each)X +2445(round.)X +2717(In)X +2813(any)X +2963(round,)X +3212(processor)X +2 f +3570(i)X +1 f +3617(transmits)X +3963(to)X +2 f +576 2732(i)N +1 f +2 f +9 f +630(+)X +1 f +700(2)X +2 f +8 s +2697(r)Y +1 f +11 s +2 f +798 2732(mod)N +1 f +2 f +978(p)X +1 f +1050(and)X +1206(receives)X +1523(an)X +1635(acknowledgment.)X +2288(A)X +2380(processor)X +2 f +2752(j)X +1 f +2806(joins)X +3007(the)X +3144(broadcast)X +3510(effort)X +3734(at)X +3827(round)X +2 f +576 2844(r)N +8 s +615 2861(j)N +1 f +11 s +640 2844(,)N +700(where)X +2 f +952(r)X +8 s +991 2861(j)N +1 f +11 s +2 f +9 f +1038 2844(=)N +1 f +2 f +1108(no.)X +1 f +2 f +1247(of)X +1 f +2 f +1345(signi\256cant)X +1 f +2 f +1742(bits)X +1 f +2 f +1899(in)X +1 f +1997(\()X +2 f +2033(j)X +1 f +2 f +9 f +2087(-)X +1 f +2 f +2157(root)X +1 f +2311(\))X +2 f +2362(mod)X +1 f +2 f +2542(p)X +1 f +(.)S +2668(In)X +2779(the)X +2924(event)X +3152(of)X +3262(processor)X +3635(failure,)X +3924(the)X +2 f +576 2956(pvmd)N +1 f +792(process)X +1081(that)X +1241(\256rst)X +1405(detects)X +1677(the)X +1812(failure)X +2069(assumes)X +2389(the)X +2524(broadcast)X +2888(duties)X +3126(of)X +3226(the)X +3361(failed)X +3589(processor.)X +3974(If)X +576 3068(the)N +709(quantity)X +1024(2\(2)X +2 f +8 s +1141 3033(r)N +1 f +11 s +1173 3068(\))N +1226(is)X +1309(less)X +1465(than)X +1641(2)X +1707(log)X +8 s +1820 3085(2)N +11 s +2 f +1881 3068(p)N +1 f +(,)S +1971(failure)X +2225(noti\256cation)X +2652(is)X +2735(piggybacked)X +3209(on)X +3321(the)X +3453(broadcast,)X +3836(at)X +3924(the)X +576 3180(end)N +733(of)X +836(which)X +1081(the)X +1219(remaining)X +1607(processors)X +2007(are)X +2144(individually)X +2602(informed.)X +2978(Otherwise,)X +3392(the)X +3531(detecting)X +3886(pro-)X +576 3292(cessor)N +817(initiates)X +1120(another)X +1406(broadcast)X +1765(with)X +1944(failure)X +2196(information,)X +2657(at)X +2743(completion)X +3163(of)X +3258(the)X +3388(current)X +3659(broadcast.)X +776 3544(The)N +2 f +950(pvmd)X +1 f +1177(processes)X +1550(execute)X +1856(a)X +1932(\256nite)X +2151(state)X +2350(machine)X +2686(which)X +2938(gives)X +3161(precedence)X +3593(to)X +3700(messages)X +576 3656(\(requests\))N +960(incoming)X +1332(while)X +1566(another)X +1867(activity)X +2170(is)X +2266(in)X +2372(progress.)X +2728(Such)X +2941(a)X +3017(scheme)X +3318(is)X +3414(adopted)X +3730(to)X +3836(avoid)X +576 3768(deadlock;)N +941(two)X +1095(processes)X +1453(transmitting)X +1903(to)X +1994(each)X +2177(other)X +2380(may)X +2554(both)X +2733(wait)X +2908(inde\256nitely)X +3334(for)X +3459(each)X +3643(others)X +3881(ack-)X +576 3880(nowledgment)N +1084(if)X +1166(this)X +1322(precedence)X +1745(rule)X +1910(were)X +2108(not)X +2249(followed.)X +2612(It)X +2694(should)X +2957(also)X +3126(be)X +3236(pointed)X +3528(out)X +3668(that)X +3828(in)X +3924(the)X +576 3992(case)N +771(of)X +3 f +9 s +884(PVM)X +1 f +11 s +1092(hardware)X +1462(platforms)X +1844(where)X +2102(wide)X +2317(area)X +2508(networks)X +2875(are)X +3027(involved,)X +3403(the)X +3556(choice)X +3831(of)X +3949(an)X +576 4104(appropriate)N +1009(timeout)X +1312(value)X +1535(can)X +1689(signi\256cantly)X +2158(affect)X +2390(the)X +2530(performance)X +3006(of)X +3111(the)X +3251(data)X +3430(transfer)X +3729(mechan-)X +576 4216(isms)N +760(and)X +909(the)X +1039(broadcast)X +1398(process.)X +1705(Further,)X +2008(the)X +2139(present)X +2416 0.2885(implementation)AX +2995(does)X +3179(not)X +3315(perform)X +3621(any)X +3771(optimi-)X +576 4328(zations)N +850(in)X +943(the)X +1075(broadcast)X +1436(scheme)X +1724(when)X +1938(a)X +2001(geographically)X +2548(distant)X +2807(host)X +2977(is)X +3059(at)X +3146(a)X +3208(non-leaf)X +3524(position)X +3832(in)X +3924(the)X +576 4440(broadcast)N +935(spanning)X +1275(tree.)X +3 f +576 4776(3.4.)N +752(Mutual)X +1053(Exclusion)X +1 f +776 5028(Mutual)N +1058(exclusion)X +1423(is)X +1509(another)X +1800(primitive)X +2153(required)X +2474(both)X +2659(in)X +2756(response)X +3091(to)X +3188(user)X +3362(requests)X +3678(as)X +3779(well)X +3959(as)X +576 5140(for)N +2 f +723(pvmd)X +1 f +958(coordination.)X +1471(Examples)X +1863(are)X +2014(exclusive)X +2391(access)X +2659(to)X +2772(emulated)X +3140(shared)X +3413(memory,)X +3773(general)X +576 5252(resource)N +928(locking,)X +1270(and)X +1452(assignment)X +1904(of)X +2033(unique)X +2329(instance)X +2674(numbers)X +3033(for)X +3191(application)X +3640(component)X +576 5364(processes.)N +973(Distributed)X +1409(mutual)X +1694(exclusion)X +2071(is)X +2168(normally)X +2525(achieved)X +2876(by)X +3002(unanimous)X +3427(or)X +3538(majority)X +3876(con-)X +576 5476(sensus;)N +871(a)X +951(requesting)X +1359(process)X +1663(that)X +1837(receives)X +2166(permission)X +2594(from)X +2806(a)X +2887(certain)X +3169(number)X +3480(of)X +3595(processes)X +3973(is)X +576 5588(deemed)N +877(to)X +973(have)X +1166(acquired)X +1496(the)X +1631(lock.)X +1832(Different)X +2181(strategies,)X +2562(varying)X +2857(in)X +2952(their)X +3140(approach,)X +3510(ef\256ciency,)X +3905(and)X +576 5700(level)N +779(of)X +883(failure)X +1144(resiliency)X +1518(have)X +1716(been)X +1914(proposed)X +2268(and)X +2427(representative)X +2953(methods)X +3284(are)X +3423(described)X +3792(in)X +3893([12,)X +576 5812(13,)N +727(14].)X +907(The)X +1085(strategy)X +1405(adopted)X +1725(in)X +3 f +9 s +1831(PVM)X +1 f +11 s +2036(is)X +2136(somewhat)X +2534(different)X +2878(from)X +3090(these)X +3312(approaches,)X +3770(but)X +3924(the)X + +14 p +%%Page: 14 14 +11 s 11 xH 0 xS 1 f +2209 400(-)N +2260(14)X +2370(-)X +576 688(algorithm)N +953(is)X +1046(ef\256cient)X +1369(and,)X +1552(more)X +1767(importantly,)X +2236(is)X +2329(integrated)X +2716(with)X +2907(the)X +3049(required)X +3376(distribution)X +3840(to)X +3943(all)X +2 f +576 800(pvmd)N +1 f +766(s)X +822(of)X +917(lock)X +1091(location)X +1398(information.)X +776 1052(A)N +2 f +862(pvmd)X +1 f +1075(process,)X +1383(either)X +1607(for)X +1732(its)X +1840(own)X +2015(purposes)X +2351(or)X +2448(on)X +2560(behalf)X +2804(of)X +2901(a)X +2964(local)X +3160(user)X +3330(process,)X +3639(attempts)X +3963(to)X +576 1164(obtain)N +821(a)X +884(lock)X +1060(by)X +1172(broadcasting)X +1646(a)X +1709("claim")X +2002(for)X +2128(the)X +2260(lock.)X +2457(Since)X +2676(all)X +2 f +2788(pvmd)X +1 f +3001(processes)X +3360(possess)X +3646(knowledge)X +576 1276(regarding)N +935(the)X +1065(use)X +1204(\(and)X +1382(location\))X +1718(of)X +1813(all)X +1924(locks,)X +2154(such)X +2337(an)X +2442(attempt)X +2730(will,)X +2912(of)X +3007(course,)X +3280(only)X +3460(be)X +3566(made)X +3780(when)X +3993(a)X +576 1388(lock)N +754(is)X +839(known)X +1104(to)X +1199(be)X +1308(free)X +1469(at)X +1558(the)X +1691(start)X +1868(of)X +1966(the)X +2099(claim.)X +2343(In)X +2441(the)X +2574(absence)X +2877(of)X +2975(con\257icting)X +3378(claims)X +3634(\(a)X +3727(situation)X +576 1500(most)N +774(likely)X +1002(to)X +1097(be)X +1206(encountered)X +1662(in)X +1757(practice\),)X +2113(the)X +2247(requester,)X +2618(after)X +2806(the)X +2941(broadcast)X +3305(has)X +3449(been)X +3642(completed,)X +576 1612(can)N +728(assume)X +1017(that)X +1180(the)X +1318(lock)X +1500(has)X +1647(been)X +1843(successfully)X +2303(obtained.)X +2659(In)X +2762(the)X +2900(process,)X +3215(all)X +3334(other)X +2 f +3544(pvmd)X +1 f +3734(s)X +3797(update)X +576 1724(their)N +766(lock)X +946(table)X +1146(information,)X +1613(and)X +1768 0.2955(\(implicitly\))AX +2201(grant)X +2411(the)X +2548(requester)X +2899(permission)X +3315(for)X +3446(exclusive)X +3808(access)X +576 1836(to)N +667(the)X +797(particular)X +1157(resource.)X +776 2088(It)N +858(is)X +945(of)X +1046(course)X +1303(possible)X +1620(that)X +1781(two)X +1941(processes)X +2305(may)X +2485(initiate)X +2760(claims)X +3019(on)X +3135(the)X +3272(same)X +3482(resource)X +3808(before)X +576 2200(either)N +802(has)X +944(received)X +1267(the)X +1399(other's)X +1667(request.)X +1989(In)X +3 f +9 s +2082(PVM)X +1 f +11 s +2246(,)X +2292(such)X +2477(situations)X +2840(are)X +2971(resolved)X +3293(using)X +3508(a)X +3571(heuristic)X +3899(that)X +576 2312(assumes)N +897(that)X +1058(communication)X +1636(between)X +1957(any)X +2112(pair)X +2277(of)X +2378(processors)X +2776(takes)X +2985(the)X +3122(same)X +3332(amount)X +3626(of)X +3728(time.)X +3959(In)X +576 2424(particular,)N +962(consider)X +1286(two)X +1444(processors)X +1840(\()X +2 f +1869(pvmd)X +1 f +2085(processes\))X +2 f +2476(A)X +1 f +2556(and)X +2 f +2709(B)X +1 f +2789(that)X +2948(wish)X +3140(to)X +3235(acquire)X +3519(the)X +3652(same)X +3858(lock,)X +576 2536(and)N +726(another)X +1013(processor)X +2 f +1372(C)X +1 f +1431(.)X +1498(Note)X +1692(that)X +1848({)X +2 f +1890(B)X +1 f +1944(,)X +2 f +(C)S +1 f +2025(})X +2090(and)X +2240({)X +2 f +2282(A)X +1 f +2336(,)X +2 f +(C)S +1 f +2417(})X +2482(are)X +2612(in)X +2705(the)X +2837(broadcast)X +3198(spanning)X +3540(trees)X +3730(of)X +2 f +3827(A)X +1 f +3905(and)X +2 f +576 2648(B)N +1 f +655(respectively,)X +1128(possibly)X +1447(at)X +1536(different)X +1864(depths.)X +2141(It)X +2219(may)X +2395(be)X +2502(assumed)X +2829(without)X +3123(loss)X +3284(of)X +3381(generality)X +3758(that)X +2 f +3915(A)X +1 f +3969('s)X +576 2760(processor)N +941(number)X +1239(is)X +1327(less)X +1488(than)X +1669(that)X +1831(of)X +2 f +1933(B)X +1 f +1987(.)X +2038(Under)X +2286(the)X +2423(constant)X +2746(time)X +2933(assumption,)X +3386(both)X +2 f +3572(A)X +1 f +3655(and)X +2 f +3811(B)X +1 f +3894(will)X +576 2872(receive)N +865(each)X +1061(others)X +1311(claims)X +1577(before)X +1836(their)X +2033(broadcast)X +2405(is)X +2499(completed.)X +2924(When)X +2 f +3168(B)X +1 f +3256(receives)X +2 f +3578(A)X +1 f +3632('s)X +3729(claim,)X +3982(it)X +576 2984(computes)N +942(the)X +1078(number)X +1376(of)X +1478(rounds)X +1746(that)X +2 f +1908(A)X +1 f +1962('s)X +2054(broadcast)X +2420(has)X +2566(proceeded;)X +2981(if)X +3064(this)X +3221(number)X +3519(is)X +3607(greater)X +3880(than)X +576 3096(the)N +708(number)X +1001(of)X +1098(rounds)X +1361(that)X +1518(its)X +1626(own)X +1801(broadcast)X +2162(has)X +2303(proceeded,)X +2 f +2710(B)X +1 f +2788(surrenders)X +3177(its)X +3285(claim)X +3505(to)X +3597(the)X +3728(lock.)X +3925(An)X +576 3208(identical)N +910(\(\256rst-claim,)X +1353(\256rst)X +1520(served\))X +1808(policy)X +2059(is)X +2148(followed)X +2491(by)X +2 f +2609(A)X +1 f +2663(.)X +2715(If)X +2803(the)X +2941(broadcast)X +3308(progress)X +3635(metrics)X +3925(are)X +576 3320(the)N +712(same,)X +943(the)X +1079(lower)X +1307(numbered)X +1687(processor)X +2051(is)X +2138(given)X +2362(priority)X +2655(and)X +2810(is)X +2896(considered)X +3304(to)X +3400(have)X +3593(obtained)X +3924(the)X +576 3432(lock.)N +773(The)X +933(passive)X +1215(processor)X +2 f +1574(C)X +1 f +1656(also)X +1821(makes)X +2069(the)X +2200(same)X +2404(decision)X +2721(since)X +2925(it)X +2998(has)X +3138(the)X +3269(capability)X +3641(of)X +3738(comput-)X +576 3544(ing)N +723(the)X +865(number)X +1168(of)X +1274(rounds)X +1546(of)X +1652(broadcast)X +2022(progress)X +2352(that)X +2518(each)X +2712(claimant)X +3050(has)X +3200(made)X +3424(when)X +3647(the)X +3788(second)X +576 3656(such)N +759(broadcast)X +1118(arrives.)X +776 3908(In)N +872(practice)X +1174(however,)X +1521(communication)X +2094(times)X +2309(between)X +2625(arbitrary)X +2951(pairs)X +3145(of)X +3242(processors)X +3636(may)X +3812(not)X +3949(be)X +576 4020(constant;)N +920(further,)X +1206(intervening)X +1633(messages)X +1990(of)X +2088(other)X +2294(types)X +2504(may)X +2680(skew)X +2884(the)X +3016(propagation)X +3461(time)X +3643(of)X +3740(a)X +3803(broad-)X +576 4132(cast)N +759(claim.)X +1046(For)X +1214(practical)X +1564(safety)X +1821(therefore,)X +2207(the)X +2362(originators)X +2791(of)X +2911(con\257icting)X +3336(claims)X +3614(exchange)X +3993(a)X +576 4244(con\256rmatory)N +1061(message)X +1389(\320)X +1507(with)X +1694(the)X +1832(claim)X +2059(being)X +2285(abandoned)X +2696(if)X +2780(their)X +2972(respective)X +3358(notions)X +3647(of)X +3749(the)X +3886(suc-)X +576 4356(cessful)N +848(claimant)X +1181(are)X +1317(not)X +1459(in)X +1557(agreement.)X +1975(In)X +2077(such)X +2267(a)X +2335(situation,)X +2691(the)X +2828(lower)X +3057(numbered)X +3438(processor)X +3803(broad-)X +576 4468(casts)N +769(a)X +830("reset)X +1054(lock")X +1264(message,)X +1606(and)X +1755(the)X +1885(entire)X +2108(process)X +2393(is)X +2474(started)X +2731(afresh,)X +2989(but)X +3124(without)X +3416(competition)X +3861(from)X +576 4580(the)N +707("losing")X +1018(processor.)X +1421(In)X +1517(case)X +1691(of)X +1787(process)X +2073(or)X +2169(processor)X +2528(failures,)X +2837(the)X +2969(strategy)X +3272(of)X +3369(all)X +2 f +3482(pvmd)X +1 f +3696(processes)X +576 4692(possessing)N +979(all)X +1095(information)X +1539(is)X +1624(used)X +1811(to)X +1906(avoid)X +2128(undesirable)X +2560(situations.)X +2947(If)X +3031(a)X +3096(process)X +3385(or)X +3484(processor)X +3846(hold-)X +576 4804(ing)N +716(a)X +782(lock)X +961(terminates)X +1356(without)X +1653(releasing)X +1998(it,)X +2097(the)X +2233(particular)X +2599(resource)X +2924(is)X +3011(marked)X +3303(as)X +3404("defunct";)X +3793(further)X +576 4916(requests)N +886(to)X +977(the)X +1107(resource)X +1426(are)X +1555(denied)X +1812(until)X +1997(an)X +2102(explicit)X +2390(reset)X +2578(is)X +2659(performed.)X +3 f +576 5252(3.5.)N +752(Process)X +1057(control)X +1 f +776 5504(The)N +942 0.3681(initiation)AX +1292(order)X +1506(and)X +1662(process)X +1954(dependencies)X +2458(of)X +2561(application)X +2984(components)X +3440(are)X +3577(described)X +3944(by)X +576 5616(the)N +710(use)X +853(of)X +952(appropriate)X +3 f +1378(initiate)X +1 f +1668(constructs)X +2050(embedded)X +2437(within)X +2688(host)X +2860(language)X +3203(control)X +3478(\257ow)X +3659(statements)X +576 5728(as)N +678(described)X +1044(in)X +1142(the)X +1279(preceding)X +1656(section.)X +1958(This)X +2145(implies)X +2436(that)X +2599(it)X +2679(is)X +2768(not)X +2911(possible)X +3230(to)X +3329(determine)X +3712(statically)X +576 5840(the)N +708(application)X +1125(process)X +1412(\257ow)X +1592(graph)X +1816(as)X +1913(component)X +2329 0.3063(initiations)AX +2708(may)X +2884(be)X +2991(conditional)X +3413(or)X +3510(repeated)X +3832(based)X + +15 p +%%Page: 15 15 +11 s 11 xH 0 xS 1 f +2209 400(-)N +2260(15)X +2370(-)X +576 688(upon)N +778(parameters)X +1190(known)X +1456(only)X +1640(at)X +1731(execution)X +2101(time.)X +2308(The)X +3 f +9 s +2468(PVM)X +1 f +11 s +2659(system)X +2931(therefore)X +3275(performs)X +3619(process)X +3909(ini-)X +576 800(tiations)N +874(in)X +980(response)X +1324(to)X +1430(requests)X +1755(based)X +1991(upon)X +2203(the)X +2347(resources)X +2714(available)X +3069(and)X +3232(load)X +3420(conditions)X +3824(at)X +3924(the)X +576 912(moment)N +889(of)X +985(the)X +1116(request)X +1393(\320)X +1504(rather)X +1732(than)X +1907(by)X +2019(constructing)X +2479(a)X +2542(predetermined)X +3075(static)X +3286(schedule)X +3618(and)X +3769(process)X +576 1024(to)N +667(processor)X +1025(assignments.)X +776 1276(When)N +1013(an)X +1123(application)X +1543(component)X +1963(process)X +2254(makes)X +2507(an)X +3 f +2618(initiate)X +1 f +2911(request,)X +3215(the)X +3351(local)X +2 f +3551(pvmd)X +1 f +3769(process)X +576 1388(\256rst)N +747(determines)X +1168(a)X +1241(candidate)X +1613(pool)X +1804(of)X +1911(target)X +2146(hosts)X +2361(based)X +2595(upon)X +2805(the)X +2947(information)X +3397(in)X +3499(the)X +3640(component)X +576 1500(description)N +990(\256le.)X +1169(One)X +1337(host)X +1506(is)X +1587(then)X +1761(selected)X +2067(from)X +2260(this)X +2410(pool)X +2589(based)X +2811(upon)X +3009(the)X +3139(following)X +3504(algorithm:)X +576 1668(\(1\))N +776(Select)X +1017(next)X +1194(host)X +1366(from)X +1562(pool)X +1744(in)X +1838(round-robin)X +2283(manner,)X +2594(based)X +2819(upon)X +3020(all)X +3134 0.3063(initiations)AX +3515(that)X +3674(originated)X +776 1780(here.)N +576 1920(\(2\))N +776(Obtain)X +1040(load)X +1216(metric)X +1467(\(decayed)X +1809(average)X +2107(of)X +2205(number)X +2499(of)X +2597(processes)X +2958(in)X +3052(run)X +3194(queue\))X +3458(from)X +3654(this)X +3807(poten-)X +776 2032(tial)N +912(target)X +1135(host.)X +576 2172(\(3\))N +776(If)X +856(this)X +1006(quantity)X +1318(is)X +1399(less)X +1553(than)X +1727(a)X +1788(prespeci\256ed)X +2235(threshold,)X +2607(select)X +2830(this)X +2980(host.)X +576 2312(\(4\))N +776(Otherwise,)X +1182(repeat)X +1420(the)X +1551(process.)X +1859(If)X +1940(no)X +2051(host)X +2221(has)X +2361(a)X +2423(load)X +2598(factor)X +2827(below)X +3066(the)X +3198(threshold,)X +3572(the)X +3704(host)X +3875(with)X +776 2424(the)N +906(lowest)X +1158(load)X +1332(is)X +1413(the)X +1543(selected)X +1849(target.)X +576 2676(Once)N +785(the)X +917(target)X +1142(host)X +1313(is)X +1396(identi\256ed,)X +1776(the)X +1908(local)X +2 f +2104(pvmd)X +1 f +2318(sends)X +2537(the)X +2669(initiate)X +2940(request)X +3218(to)X +3311(the)X +2 f +3443(pvmd)X +1 f +3657(process)X +3944(on)X +576 2788(the)N +712(remote)X +985(host,)X +1182(where)X +1424(the)X +1560(application)X +1981(component)X +2401(is)X +2488(initiated.)X +2829(The)X +2993(remote)X +2 f +3265(pvmd)X +1 f +3482(then)X +3661(broadcasts)X +576 2900(noti\256cation)N +1009(of)X +1112(this)X +1270(event)X +1491(to)X +1590(all)X +1709(processors,)X +2131(simultaneously)X +2696(claiming)X +3037(an)X +3151(instance)X +3471(number)X +3771(for)X +3904(this)X +576 3012 0.3681(initiation)AN +949(\(by)X +1118(simply)X +1411(incrementing)X +1929(the)X +2089(last)X +2263(previous)X +2617(instance)X +2957(number)X +3277(for)X +3430(the)X +3589(component\).)X +576 3124(Con\257icting)N +1008(claims)X +1273(for)X +1409(the)X +1551(same)X +1766(instance)X +2089(number)X +2392(are)X +2533(again)X +2758(resolved)X +3090(as)X +3197(in)X +3300(the)X +3442(case)X +3628(of)X +3736(multiple)X +576 3236(claims)N +837(to)X +936(a)X +1005(lock,)X +1209(with)X +1395(a)X +1463("losing")X +1780(processor)X +2145(using)X +2365(a)X +2433(higher)X +2687(value.)X +2929(Once)X +3143(again,)X +3385(consistent)X +3767(con\257ict)X +576 3348(resolution)N +958(is)X +1046(con\256rmed)X +1432(by)X +1549(an)X +1661(exchange)X +2022(of)X +2124(messages)X +2485(between)X +2807(all)X +2925(claimants)X +3293(and)X +3449(reset)X +3645(actions)X +3925(are)X +576 3460(performed)N +985(in)X +1097(the)X +1248(case)X +1442(of)X +1558(disagreement.)X +2115(Application)X +2575(process)X +2880(termination)X +3330(information)X +3789(is)X +3890(also)X +576 3572(broadcast)N +937(to)X +1030(all)X +2 f +1143(pvmd)X +1 f +1357(processes.)X +1739(Conditional)X +2181(variants)X +2484(of)X +3 f +2581(initiate)X +1 f +2870(are)X +3001(saved)X +3225(by)X +3338(the)X +3471(local)X +2 f +3668(pvmd)X +1 f +3858(,)X +3905(and)X +576 3684(this)N +726(queue)X +958(is)X +1039(inspected)X +1394(and)X +1543(appropriate)X +1966(action)X +2204(taken)X +2417(when)X +2629(the)X +2759(particular)X +3119(event)X +3332(occurs.)X +3 f +576 4020(3.6.)N +752(Shared)X +1043(Memory)X +1387(and)X +1551(Barriers)X +1 f +776 4272(In)N +872(the)X +3 f +9 s +999(PVM)X +1 f +11 s +1187(system,)X +1478(shared)X +1731(memory)X +2049(is)X +2132(emulated)X +2480(by)X +2592(\256rst)X +2753(creating)X +3061(an)X +3168(image)X +3408(of)X +3505(a)X +3568(memory)X +3886(seg-)X +576 4384(ment)N +780(on)X +895(secondary)X +1278(storage.)X +1581(A)X +1671(\256le)X +1811(of)X +1911(the)X +2046(requested)X +2410(size)X +2574(is)X +2660(created;)X +2966(for)X +3094(ef\256ciency)X +3467(and)X +3620(failure)X +3876(resi-)X +576 4496(liency)N +815(reasons,)X +1123(the)X +1254(local)X +2 f +1449(pvmd)X +1 f +1662(\(the)X +1823(processor)X +2183(at)X +2271(which)X +2510(the)X +2642(creation)X +2950(request)X +3228(originated\))X +3639(attempts)X +3963(to)X +576 4608(locate)N +811(the)X +943(\256le)X +1080(on)X +1192(a)X +1255(device)X +1509(that)X +1666(is)X +1749(accessible)X +2130(to)X +2223(other)X +2428(processors)X +2822(via)X +2954(a)X +3017(network)X +3329(\256le)X +3465(system.)X +3777(Mutual)X +576 4720(exclusion,)N +958(both)X +1137(for)X +1261(creation)X +1567(as)X +1662(well)X +1836(as)X +1932(for)X +2057(access,)X +2326(is)X +2408(achieved)X +2744(as)X +2840(described)X +3200(earlier.)X +3470(A)X +2 f +3556(pvmd)X +1 f +3769(process)X +576 4832(that)N +732(has)X +872(acquired)X +1198(a)X +1259(lock)X +1433(\(on)X +1572(behalf)X +1814(of)X +1909(a)X +1970(local)X +2164(application)X +2579(process\))X +2893(copies)X +3140(the)X +3270(\256le)X +3405(into)X +3565(the)X +3695(requested)X +576 4944(address)N +864(space;)X +1109(this)X +1262(is)X +1346(done)X +1542(directly)X +1838(if)X +1918(the)X +2052(\256le)X +2191(is)X +2276(accessible)X +2659(directly,)X +2977(and)X +3130(with)X +3313(the)X +3447(assistance)X +3825(of)X +3924(the)X +576 5056(remote)N +2 f +846(pvmd)X +1 f +1061(if)X +1140(it)X +1215(is)X +1299(not.)X +1459(A)X +1547(user)X +1718(release)X +1987(request)X +2266(results)X +2521(in)X +2615(the)X +2748(speci\256ed)X +3086(memory)X +3405(area)X +3576(being)X +3797(copied)X +576 5168(back)N +766(to)X +859(the)X +991(\256le)X +1128(unless)X +1372(the)X +1504(lock)X +1680(request)X +1958(was)X +2118(for)X +2245(read-only)X +2607(access.)X +2900(It)X +2979(should)X +3239(be)X +3347(noted)X +3568(that)X +3726(creation,)X +576 5280(locking,)N +888(unlocking,)X +1288(and)X +1440(deallocation)X +1897(\(resulting)X +2260(in)X +2354(\256le)X +2492(removal\))X +2835(events)X +3085(are)X +3216(broadcast)X +3577(to)X +3670(all)X +2 f +3783(pvmd)X +1 f +3973(s;)X +576 5392(given)N +803(the)X +942(con\257ict)X +1238(resolution)X +1622(rules)X +1824(and)X +1982(highest)X +2268(priority)X +2564(to)X +2664(incoming)X +3029(requests,)X +3370(undesirable)X +3807(incon-)X +576 5504(sistencies)N +936(are)X +1065(avoided.)X + +16 p +%%Page: 16 16 +11 s 11 xH 0 xS 1 f +2209 400(-)N +2260(16)X +2370(-)X +776 688(Barrier)N +1047(synchronization)X +1632(in)X +3 f +9 s +1719(PVM)X +1 f +11 s +1905(is)X +1986(accomplished)X +2493(by)X +2604(using)X +2818(an)X +2924(ef\256cient)X +3236(algorithm)X +3603(described)X +3963(in)X +576 800([20].)N +770(The)X +932(algorithm)X +1301(considers)X +1658(the)X +2 f +1791(pvmd)X +1 f +2006(processes)X +2367(as)X +2465(being)X +2686(the)X +2819(vertices)X +3118(in)X +3212(a)X +3276(logical)X +3542(quadratic)X +3895(net-)X +576 912(work.)N +803(In)X +901(such)X +1087(a)X +1151(network)X +1464(each)X +1650(vertex)X +2 f +1895(i)X +1 f +1945(has)X +2087(outgoing)X +2426(links)X +2623(to)X +2 f +2725(j)X +1 f +2776(such)X +2963(that)X +2 f +3129(j)X +1 f +2 f +9 f +3183(=)X +1 f +2 f +3253(i)X +1 f +2 f +9 f +3307(+)X +1 f +3377(2)X +2 f +8 s +877(r)Y +1 f +11 s +2 f +3475 912(modN)N +1 f +3685(,)X +3733(where)X +2 f +3973(N)X +1 f +576 1024(is)N +660(the)X +793(number)X +1087(of)X +2 f +1185(pvmd)X +1 f +1399(processes,)X +1781(and)X +1932(0)X +9 f +1998(\243)X +2 f +2068(r)X +1 f +2 f +2131(<)X +1 f +2212(log)X +8 s +2325 1041(2)N +11 s +2 f +2386 1024(N)N +1 f +2445(.)X +2491(Upon)X +2710(receipt)X +2974(of)X +3071(a)X +3 f +3134(barrier)X +1 f +3432(request)X +3710(from)X +3905(one)X +576 1136(of)N +673(the)X +806(local)X +1003(application)X +1421(processes,)X +1804(each)X +2 f +1990(pvmd)X +1 f +2205(process)X +2 f +2493(i)X +1 f +2543(\256rst)X +2705(waits)X +2916(until)X +3104(all)X +3218(local)X +3415(components)X +3866(have)X +576 1248(also)N +740(reached)X +1035(the)X +1165(barrier,)X +1443(and)X +1592(then)X +1766(executes)X +2091(the)X +2221(following)X +2586(algorithm:)X +796 1388(for)N +2 f +920(r)X +1 f +976(:=)X +1073(0)X +1139(to)X +1230(log)X +8 s +1343 1405(2)N +11 s +2 f +1404 1388(N)N +1 f +2 f +9 f +1492(-)X +1 f +1562(1)X +1628(do)X +928 1500(send)N +1111(message)X +1431(containing)X +2 f +1826(r)X +1 f +1882(to)X +2 f +1973(i)X +1 f +2 f +9 f +2027(+)X +1 f +2097(2)X +2 f +8 s +1465(r)Y +1 f +11 s +2 f +2195 1500(mod)N +1 f +2 f +2375(N)X +1 f +928 1612(wait)N +1102(for)X +1226(receipt)X +1488(of)X +1583(message)X +1903(containing)X +2 f +2298(r)X +1 f +576 1864(This)N +762(algorithm)X +1135(is)X +1223(ef\256cient)X +1541(both)X +1727(in)X +1825(the)X +1962(number)X +2261(of)X +2364(messages)X +2726(used)X +2917(and)X +3074(the)X +3212(number)X +3511(of)X +3614(rounds,)X +3905(and)X +576 1976(may)N +750(be)X +855(used)X +1038(for)X +1162(arbitrary)X +1487(values)X +1734(of)X +2 f +1829(N)X +1 f +1888(.)X +3 f +576 2312(3.7.)N +752(Discussion)X +1 f +776 2564(An)N +914(overview)X +1272(of)X +1376(the)X +1515(design)X +1776(and)X +1934 0.2885(implementation)AX +2521(strategies)X +2885(used)X +3077(to)X +3177(realize)X +3443(the)X +3582(various)X +3 f +9 s +3868(PVM)X +1 f +11 s +576 2676(features)N +885(has)X +1033(been)X +1230(presented)X +1598(in)X +1698(this)X +1857(section.)X +2160(As)X +2287(is)X +2376(common)X +2715(with)X +2902(most)X +3104(software)X +3436(systems,)X +3767(there)X +3973(is)X +576 2788(sometimes)N +980(a)X +1045(tradeoff)X +1349(between)X +1669(versatility)X +2050(and)X +2204(ef\256ciency.)X +2600(In)X +3 f +9 s +2696(PVM)X +1 f +11 s +2860(,)X +2909(the)X +3044(shared)X +3300(memory)X +3621(facility)X +3899(that)X +576 2900(is)N +664(emulated)X +1017(on)X +1134(a)X +1202(network)X +1519(is)X +1607(likely)X +1837(to)X +1934(be)X +2045(the)X +2181(cause)X +2404(of)X +2505(performance)X +2977(degradation)X +3421(if)X +3503(used)X +3692(unwisely.)X +576 3012(However,)N +948(as)X +1050(has)X +1196(been)X +1391(pointed)X +1685(out,)X +1849(when)X +2068(the)X +2205(grainsize)X +2552(of)X +2654(sharing)X +2943(memory)X +3267(across)X +3516(the)X +3654(distributed)X +576 3124(environment)N +1058(is)X +1152(relatively)X +1521(large,)X +1754(acceptable)X +2161(ef\256ciency)X +2543(levels)X +2784(may)X +2971(be)X +3089(obtained;)X +3453(and)X +3615(the)X +3758(bene\256ts)X +576 3236(obtained)N +920(by)X +1048(the)X +1196(shared)X +1466(memory)X +1801(abstraction)X +2229(outweighs)X +2632(the)X +2781(small)X +3014(performance)X +3499(degradation.)X +3978(It)X +576 3348(should)N +839(be)X +950(noted)X +1174(that)X +1335(mutual)X +1608(exclusion)X +1973(and)X +2127(barrier)X +2388(synchronization)X +2978(are)X +3112(implemented)X +3601(independent)X +576 3460(of)N +679(the)X +817(shared)X +1076(memory)X +1400(mechanism)X +1832(and)X +1990(use)X +2138(algorithms)X +2547(that)X +2711(are)X +2849(known)X +3119(to)X +3219(be)X +3333(ef\256cient)X +3653(for)X +3786(tens)X +3959(of)X +576 3572(processors)N +968(on)X +1078(local)X +1272(networks.)X +3 f +576 3908(4.)N +686(Preliminary)X +1164(Results)X +1 f +776 4160(To)N +910(facilitate)X +1256(its)X +1376(use)X +1529(and)X +1692(to)X +1797(determine)X +2186(its)X +2306(effectiveness,)X +2823(the)X +3 f +9 s +2963(PVM)X +1 f +11 s +3163(system)X +3444(has)X +3598(been)X +3801(imple-)X +576 4272(mented)N +865(on)X +982(a)X +1050(variety)X +1324(of)X +1426(machines)X +1788(including)X +2151(Sun)X +2316(3/50,)X +2523(3/60)X +2708(and)X +2863(SparcStation1)X +3386(workstations,)X +3886(Vax)X +576 4384(11/785)N +854(and)X +1014(Sun)X +1184(4/280)X +1418(servers,)X +1721(a)X +1793(64)X +1914(node)X +2119(Intel)X +2315(iPSC/2)X +2600(hypercube,)X +3022(and)X +3183(a)X +3256(12)X +3378(processor)X +3748(Sequent)X +576 4496(shared-memory)N +1157(multiprocessor.)X +1732(The)X +1898(minimal)X +2223(assumptions)X +2688(made)X +2908(regarding)X +3274(the)X +3411(underlying)X +3821(facili-)X +576 4608(ties)N +725(available)X +1070(greatly)X +1341(simpli\256ed)X +1721(the)X +1855 0.2885(implementation)AX +2437(efforts;)X +2717(the)X +2852(software)X +3181(could)X +3404(be)X +3514(ported)X +3766(\(from)X +3993(a)X +576 4720(base)N +773(Sun)X +951(3)X +1036 0.2455(implementation\))AX +1662(to)X +1772(to)X +1881(all)X +2010(the)X +2158(environments)X +2678(with)X +2875(changes)X +3198(necessary)X +3579(only)X +3776(in)X +3885(data)X +576 4832(representation)N +1105(and)X +1262(conversion)X +1678 0.3403(utilities.)AX +1997(In)X +2101(the)X +2240 0.2679(implementation,)AX +2849(the)X +2 f +2988(pvmd)X +1 f +3209(processes)X +3576(run)X +3724(indepen-)X +576 4944(dently,)N +844(while)X +1065(the)X +1198(user)X +1369(level)X +1566(routines)X +1875(are)X +2007(supplied)X +2331(as)X +2429(a)X +2493(set)X +2616(of)X +2714(libraries)X +3028(to)X +3122(be)X +3229(linked)X +3474(in)X +3567(with)X +3748(applica-)X +576 5056(tion)N +739(components.)X +1235(This)X +1418(section)X +1694(reports)X +1964(on)X +2078(observed)X +2421(performance)X +2891(\256gures)X +3156(for)X +3284(the)X +3418(basic)X +3 f +9 s +3621(PVM)X +1 f +11 s +3811(primi-)X +576 5168(tives)N +772(and)X +928(two)X +1089(straightforward)X +1660(applications;)X +2141(in)X +2239(the)X +2376(next)X +2556(section,)X +2856(two)X +3016(other)X +3225(applications)X +3680(that)X +3841(make)X +576 5280(extensive)N +931(use)X +1070(of)X +1165(the)X +1295(heterogeneous)X +1825(facilities)X +2152(are)X +2281(described.)X + +17 p +%%Page: 17 17 +11 s 11 xH 0 xS 1 f +2209 400(-)N +2260(17)X +2370(-)X +3 f +576 688(4.1.)N +752(Basic)X +975(Primitives)X +1 f +776 940(The)N +945(ef\256ciency)X +1324(of)X +1429(user-level)X +1808(data)X +1987(transfer)X +2287(is)X +2378(perhaps)X +2683(the)X +2823(most)X +3027(critical)X +3305(aspect)X +3557(of)X +3662(any)X +3821(distri-)X +576 1052(buted)N +804(computing)X +1214(environment.)X +1714(In)X +1819(the)X +3 f +9 s +1955(PVM)X +1 f +11 s +2150(system,)X +2448(low)X +2611(latency)X +2897(data)X +3075(transfer)X +3374(has)X +3522(been)X +3719(provided)X +576 1164(without)N +877(sacri\256cing)X +1276(location)X +1593(transparency,)X +2096(and)X +2255(a)X +2326(datagram)X +2686(protocol)X +3012(is)X +3103(used)X +3296(so)X +3406(that)X +3571(overheads)X +3959(of)X +576 1276(more)N +791(heavyweight)X +1275(protocols)X +1636(are)X +1776(avoided.)X +2110(It)X +2197(is)X +2289(anticipated)X +2710(that)X +2876(a)X +2948(large)X +3157(proportion)X +3562(of)X +3668(the)X +3809(use)X +3959(of)X +3 f +9 s +576 1388(PVM)N +1 f +11 s +764(will)X +926(be)X +1033(constrained)X +1463(to)X +1557(local)X +1754(networks,)X +2123(with)X +2305(only)X +2487(a)X +2551(few)X +2707(applications)X +3159(wishing)X +3463(to)X +3557(execute)X +3851(com-)X +576 1500(ponents)N +873(on)X +984(geographically)X +1531(distant)X +1790(hosts.)X +2016(The)X +2176(protocols)X +2527(used)X +2711(by)X +3 f +9 s +2818(PVM)X +1 f +11 s +3004(therefore)X +3343(incur)X +3546(the)X +3676(overheads)X +576 1612(of)N +679(retransmission)X +1223(and)X +1380(sequencing)X +1806(only)X +1993(when)X +2213(the)X +2352(underlying)X +2765(network)X +3084(quality)X +3361(is)X +3451(poor;)X +3668(more)X +3880(than)X +576 1724(95%)N +766(of)X +868(local)X +1069(network)X +1386(communications)X +1999(typically)X +2337(succeed)X +2643(on)X +2759(the)X +2895(\256rst)X +3060(attempt.)X +3376(Table)X +3605(1)X +3677(shows)X +3924(the)X +576 1836(message)N +897(delivery)X +1209(times)X +1424(for)X +1549(varying)X +1841(message)X +2162(sizes)X +2356(under)X +3 f +9 s +2575(PVM)X +1 f +11 s +2763(between)X +3080(two)X +3236(Sun)X +3397(3/50)X +3578(systems)X +3881(on)X +3993(a)X +576 1948(10)N +695(MB/s)X +922(Ethernet.)X +1273(It)X +1357(should)X +1622(be)X +1735(noted)X +1961(that)X +2124(these)X +2335(\256gures)X +2604(represent)X +2956(elapsed)X +3250(time)X +3438(from)X +3639(the)X +3777(start)X +3959(of)X +576 2060(message)N +906(transmission)X +1384(to)X +1486(the)X +1627(receipt)X +1900(of)X +2006(positive)X +2319(acknowledgment)X +2954(and)X +3114(are)X +3254(averages)X +3594(over)X +3783(several)X +576 2172(runs)N +749(performed)X +1137(under)X +1359(varying)X +1650(host)X +1819(and)X +1968(network)X +2278(loads.)X +10 f +1022 2364(i)N +1034(iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii)X +1 f +1066 2476(Message)N +1395(size)X +1554(\(bytes\))X +2033(8)X +2334(128)X +2679(256)X +3024(512)X +3347(1024)X +10 f +1022 2492(i)N +1034(iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii)X +1022 2508(i)N +1034(iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii)X +1 f +1066 2612(First)N +1250(instance)X +1949(15)X +2059(ms)X +2294(18)X +2404(ms)X +2639(22)X +2749(ms)X +2984(25)X +3094(ms)X +3329(30)X +3439(ms)X +10 f +1022 2636(i)N +1034(iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii)X +1 f +1066 2748(Subsequent)N +1494(instances)X +1971(6)X +2037(ms)X +2316(8)X +2382(ms)X +2639(10)X +2749(ms)X +2984(12)X +3094(ms)X +3329(15)X +3439(ms)X +10 f +1022 2772(i)N +1034(iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii)X +1022(c)X +2716(c)Y +2628(c)Y +2540(c)Y +2452(c)Y +1883 2772(c)N +2716(c)Y +2628(c)Y +2540(c)Y +2452(c)Y +2228 2772(c)N +2716(c)Y +2628(c)Y +2540(c)Y +2452(c)Y +2573 2772(c)N +2716(c)Y +2628(c)Y +2540(c)Y +2452(c)Y +2918 2772(c)N +2716(c)Y +2628(c)Y +2540(c)Y +2452(c)Y +3263 2772(c)N +2716(c)Y +2628(c)Y +2540(c)Y +2452(c)Y +3586 2772(c)N +2716(c)Y +2628(c)Y +2540(c)Y +2452(c)Y +1 f +1436 2932(Table)N +1659(1)X +1725(:)X +1772(User)X +1959(process)X +2244(data)X +2413(transfer)X +2703(times)X +2917(in)X +3 f +9 s +3008(PVM)X +1 f +11 s +576 3184(Broadcast,)N +976(since)X +1183(it)X +1259(is)X +1344(used)X +1531(heavily)X +1817(within)X +3 f +9 s +2065(PVM)X +1 f +11 s +2229(,)X +2277(is)X +2363(another)X +2654(important)X +3025(factor)X +3257(in)X +3353(the)X +3488(performance)X +3959(of)X +576 3296(the)N +708(system.)X +999(It)X +1077(was)X +1237(observed)X +1578(that)X +1734(for)X +1859(broadcast)X +2219(among)X +2 f +2482(pvmd)X +1 f +2695(processes,)X +3076(the)X +3207(calculated)X +3588(performance)X +576 3408(of)N +679(the)X +817(recursive)X +1169(doubling)X +1513(algorithm)X +1887(is)X +1976(consistent)X +2359(with)X +2546(actual)X +2788(behavior.)X +3171(Acknowledged)X +3734(message)X +576 3520(transmission)N +1057(on)X +1180(a)X +1254(single)X +1500(branch)X +1774(of)X +1882(the)X +2024(broadcast)X +2395(spanning)X +2747(tree)X +2913(required)X +3240(between)X +3567(4)X +3645(and)X +3806(9)X +3884(mil-)X +576 3632(liseconds)N +929(for)X +1056(a)X +1120(\(typical\))X +1444(100-byte)X +1782(message,)X +2128(depending)X +2521(upon)X +2723(the)X +2857(speed)X +3083(and)X +3236(load)X +3414(on)X +3528(the)X +3662(processors)X +576 3744(involved.)N +969(This)X +1166(translated)X +1549(to)X +1658(measured)X +2034(\256gures)X +2312(of)X +2424(15,)X +2573(28,)X +2722(35,)X +2871(and)X +3037(50)X +3164(milliseconds)X +3650(for)X +3791(typical)X +576 3856(broadcasts)N +979(to)X +1080(3,)X +1178(7,)X +1276(15,)X +1418(and)X +1577(31)X +1697(hosts)X +1910(respectively.)X +2412(For)X +2566(user)X +2744(process)X +3039(broadcasts,)X +3464(the)X +3604(\256gures)X +3876(vary)X +576 3968(widely,)N +866(owing)X +1114(to)X +1211(the)X +1347(fact)X +1507(that)X +2 f +1668(pvmd)X +1 f +1885(processes)X +2248(deliver)X +2520(broadcasts)X +2918(sequentially)X +3372(to)X +3468(local)X +3667(recipients.)X +576 4080(Thus,)N +799(if)X +878(a)X +942(large)X +1143(percentage)X +1549(of)X +1648(the)X +1782(user)X +1954(process)X +2243(broadcast)X +2606(group)X +2837(were)X +3033(physically)X +3422(executing)X +3791(on)X +3905(one)X +576 4192(host,)N +773(the)X +909(sequential)X +1295(delivery)X +1612(time)X +1798(for)X +1928(that)X +2089(host)X +2264(would)X +2512(dominate)X +2869(the)X +3004(total)X +3189(broadcast)X +3553(time.)X +3760(Table)X +3988(2)X +576 4304(shows)N +835(typical)X +1116(time)X +1314(requirements)X +1814(for)X +1956(user)X +2142(broadcast,)X +2541(under)X +2781(the)X +2929(assumption)X +3372(that)X +3546(the)X +3695(broadcast)X +576 4416(groups)N +837(are)X +966(evenly)X +1223(distributed)X +1623(among)X +1885(participating)X +2354(hosts.)X +776 4808(For)N +926(access)X +1179(to)X +1277(shared)X +1535(memory)X +1858(segments,)X +3 f +9 s +2233(PVM)X +1 f +11 s +2426(performance)X +2899(was)X +3064(good,)X +3291(although)X +3629(the)X +3766(timings)X +576 4920(varied)N +823(signi\256cantly,)X +1309(depending)X +1703(upon)X +1906(the)X +2041(number)X +2337(of)X +2437(active)X +2 f +2675(pvmd)X +1 f +2891(processes)X +3253(as)X +3352(well)X +3530(as)X +3629(the)X +3763(number)X +576 5032(of)N +681(con\257icting)X +1091(requests.)X +1433(It)X +1519(was)X +1687(empirically)X +2122(determined)X +2551(that)X +2716(the)X +2856(average)X +3161(time)X +3351(to)X +3452(access)X +3708(emulated)X +576 5144(shared)N +827(memory)X +1143(could)X +1361(be)X +1466(expressed)X +1834(as)X +2 f +796 5368(Time)N +8 s +5385(ms)Y +1 f +11 s +2 f +9 f +1072 5368(=)N +1 f +1142(12)X +2 f +9 f +1252(\264)X +1 f +2 f +1322(#)X +1 f +2 f +1395(of)X +1 f +2 f +1493(pvmd)X +1 f +2 f +1712(processes)X +1 f +2 f +9 f +2082(+)X +1 f +2152(0.04)X +2 f +9 f +2328(\264)X +1 f +2 f +2398(segment_size)X +8 s +2862 5385(bytes)N +1 f +11 s +576 5620(for)N +705(shared)X +961(memory)X +1282(segments)X +1637(of)X +1737(size)X +1901(256)X +2060(bytes)X +2274(and)X +2429(larger.)X +2684(the)X +2820(\256rst)X +2985(term)X +3175(in)X +3272(the)X +3408(expression)X +3812(is)X +3899(that)X +576 5732(required)N +894(for)X +1021(locking)X +1311(the)X +1444(segment,)X +1785(this)X +1938(term)X +2125(is)X +2209(dominant)X +2568(and)X +2720(increases)X +3067(with)X +3249(the)X +3381(number)X +3674(of)X +3771(distinct)X +576 5844(participating)N +1048(processors.)X +1465(An)X +1597(alternative)X +1996(mutual)X +2268(exclusion)X +2632(algorithm)X +3002(that)X +3161(reduced)X +3465(the)X +3599(effect)X +3825(of)X +3924(the)X + +18 p +%%Page: 18 18 +11 s 11 xH 0 xS 1 f +2209 400(-)N +2260(18)X +2370(-)X +10 f +890 656(i)N +901(iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii)X +1 f +1007 768(No.)N +1158(of)X +1492(No.)X +1643(of)X +2422(Message)X +2751(size)X +2910(\(bytes\))X +934 880(processors)N +1436(processes)X +1988(8)X +2311(128)X +2700(256)X +3089(512)X +3456(1024)X +10 f +890 896(i)N +901(iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii)X +890 912(i)N +901(iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii)X +1 f +1119 1016(4)N +1604(4)X +1904(18)X +2014(ms)X +2293(22)X +2403(ms)X +2682(26)X +2792(ms)X +3071(30)X +3181(ms)X +3460(35)X +3570(ms)X +10 f +890 1040(i)N +901(iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii)X +1 f +1119 1152(4)N +1604(8)X +1904(21)X +2014(ms)X +2293(26)X +2403(ms)X +2682(30)X +2792(ms)X +3071(35)X +3181(ms)X +3460(41)X +3570(ms)X +10 f +890 1176(i)N +901(iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii)X +1 f +1119 1288(8)N +1604(8)X +1904(39)X +2014(ms)X +2293(48)X +2403(ms)X +2682(60)X +2792(ms)X +3071(75)X +3181(ms)X +3460(90)X +3570(ms)X +10 f +890 1312(i)N +901(iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii)X +1 f +1119 1424(8)N +1560(16)X +1904(47)X +2014(ms)X +2293(57)X +2403(ms)X +2682(70)X +2792(ms)X +3071(86)X +3181(ms)X +3416(105)X +3570(ms)X +10 f +890 1448(i)N +901(iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii)X +1 f +1075 1560(16)N +1560(16)X +1904(65)X +2014(ms)X +2293(76)X +2403(ms)X +2682(91)X +2792(ms)X +3027(110)X +3181(ms)X +3416(130)X +3570(ms)X +10 f +890 1584(i)N +901(iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii)X +1 f +1075 1696(16)N +1560(32)X +1904(95)X +2014(ms)X +2249(110)X +2403(ms)X +2638(125)X +2792(ms)X +3027(145)X +3181(ms)X +3416(180)X +3570(ms)X +10 f +890 1720(i)N +901(iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii)X +890(c)X +1712(c)Y +1624(c)Y +1536(c)Y +1448(c)Y +1360(c)Y +1272(c)Y +1184(c)Y +1096(c)Y +1008(c)Y +920(c)Y +832(c)Y +744(c)Y +1370 1720(c)N +1712(c)Y +1624(c)Y +1536(c)Y +1448(c)Y +1360(c)Y +1272(c)Y +1184(c)Y +1096(c)Y +1008(c)Y +920(c)Y +832(c)Y +744(c)Y +1838 1720(c)N +1712(c)Y +1624(c)Y +1536(c)Y +1448(c)Y +1360(c)Y +1272(c)Y +1184(c)Y +1096(c)Y +1008(c)Y +920(c)Y +832(c)Y +744(c)Y +2183 1720(c)N +1704(c)Y +1616(c)Y +1528(c)Y +1440(c)Y +1352(c)Y +1264(c)Y +1176(c)Y +1088(c)Y +1000(c)Y +2572 1720(c)N +1704(c)Y +1616(c)Y +1528(c)Y +1440(c)Y +1352(c)Y +1264(c)Y +1176(c)Y +1088(c)Y +1000(c)Y +2961 1720(c)N +1704(c)Y +1616(c)Y +1528(c)Y +1440(c)Y +1352(c)Y +1264(c)Y +1176(c)Y +1088(c)Y +1000(c)Y +3350 1720(c)N +1704(c)Y +1616(c)Y +1528(c)Y +1440(c)Y +1352(c)Y +1264(c)Y +1176(c)Y +1088(c)Y +1000(c)Y +3717 1720(c)N +1712(c)Y +1624(c)Y +1536(c)Y +1448(c)Y +1360(c)Y +1272(c)Y +1184(c)Y +1096(c)Y +1008(c)Y +920(c)Y +832(c)Y +744(c)Y +1 f +1449 1880(Table)N +1672(2)X +1738(:)X +1785(User)X +1972(process)X +2257(broadcast)X +2616(timings)X +2904(in)X +3 f +9 s +2995(PVM)X +1 f +11 s +576 2104(\256rst)N +739(term)X +927(by)X +1041(about)X +1263(40%)X +1450(is)X +1535(available)X +1880(and)X +2033(may)X +2211(be)X +2320(used,)X +2529(but)X +2668(the)X +2803(failure)X +3060(resilience)X +3425(properties)X +3804(of)X +3904(this)X +576 2216(protocol)N +892(are)X +1021(considered)X +1424(inadequate.)X +776 2468(Owing)N +1037(to)X +1129(the)X +1260(manner)X +1547(in)X +1639(which)X +1877(process)X +2163 0.3681(initiation)AX +2507(and)X +2657(mutual)X +2926(exclusion)X +3287(are)X +3417(implemented,)X +3924(the)X +576 2580(time)N +759(taken)X +975(for)X +1101(these)X +1306(operations)X +1697(are)X +1828(almost)X +2088(identical)X +2417(to)X +2510(that)X +2667(for)X +2793(100-byte)X +3130(broadcasts)X +3525(between)X +2 f +3842(pvmd)X +1 f +576 2692(processes.)N +978(For)X +1122(barrier)X +1378(synchronization,)X +1985(it)X +2057(was)X +2216(once)X +2405(again)X +2619(observed)X +2959(that)X +3115(the)X +3246(sequential)X +3627(handling)X +3959(of)X +576 2804(component)N +992(instances)X +1339(on)X +1451(a)X +1514(local)X +1710(processor)X +2069(could)X +2288(be)X +2394(dominant,)X +2773(if)X +2850(there)X +3049(were)X +3242(a)X +3304(large)X +3503(number)X +3795(of)X +3891(par-)X +576 2916(ticipants)N +912(on)X +1036(any)X +1199(one)X +1362(machine.)X +1720(To)X +1855(measure)X +2185(the)X +2330(performance)X +2811(of)X +2921(the)X +3066(barrier)X +3 f +9 s +3333(PVM)X +1 f +11 s +3534(primitive)X +3896(was)X +576 3028(tested)N +805(using)X +1019(a)X +1081(sample)X +1354(application)X +1770(that)X +1926(invoked)X +2232(the)X +3 f +2362(barrier)X +1 f +2658(construct)X +3003(twice)X +3216(consecutively,)X +3745(with)X +3924(the)X +576 3140(second)N +842(invocation)X +1237(being)X +1455(timed.)X +1701(Shown)X +1967(in)X +2058(Table)X +2281(3)X +2347(are)X +2476(the)X +2606(observed)X +2945(measurements.)X +10 f +1638 3332(i)N +1649(iiiiiiiiiiiiiiiiiiiiiiiiiiiiii)X +1 f +1755 3444(No.)N +1906(of)X +2240(No.)X +2391(of)X +2695(Time)X +1682 3556(processors)N +2184(processes)X +2652(\(msecs\))X +10 f +1638 3572(i)N +1649(iiiiiiiiiiiiiiiiiiiiiiiiiiiiii)X +1638 3588(i)N +1649(iiiiiiiiiiiiiiiiiiiiiiiiiiiiii)X +1 f +1867 3692(4)N +2352(4)X +2766(24)X +10 f +1638 3716(i)N +1649(iiiiiiiiiiiiiiiiiiiiiiiiiiiiii)X +1 f +1867 3828(4)N +2352(8)X +2766(58)X +10 f +1638 3852(i)N +1649(iiiiiiiiiiiiiiiiiiiiiiiiiiiiii)X +1 f +1867 3964(8)N +2352(8)X +2766(55)X +10 f +1638 3988(i)N +1649(iiiiiiiiiiiiiiiiiiiiiiiiiiiiii)X +1 f +1867 4100(8)N +2308(16)X +2722(120)X +10 f +1638 4124(i)N +1649(iiiiiiiiiiiiiiiiiiiiiiiiiiiiii)X +1 f +1823 4236(16)N +2308(16)X +2722(120)X +10 f +1638 4260(i)N +1649(iiiiiiiiiiiiiiiiiiiiiiiiiiiiii)X +1 f +1823 4372(16)N +2308(32)X +2722(270)X +10 f +1638 4396(i)N +1649(iiiiiiiiiiiiiiiiiiiiiiiiiiiiii)X +1 f +1823 4508(32)N +2308(32)X +2722(268)X +10 f +1638 4532(i)N +1649(iiiiiiiiiiiiiiiiiiiiiiiiiiiiii)X +1 f +1823 4644(32)N +2308(64)X +2722(605)X +10 f +1638 4668(i)N +1649(iiiiiiiiiiiiiiiiiiiiiiiiiiiiii)X +1638(c)X +4652(c)Y +4564(c)Y +4476(c)Y +4388(c)Y +4300(c)Y +4212(c)Y +4124(c)Y +4036(c)Y +3948(c)Y +3860(c)Y +3772(c)Y +3684(c)Y +3596(c)Y +3508(c)Y +3420(c)Y +2118 4668(c)N +4652(c)Y +4564(c)Y +4476(c)Y +4388(c)Y +4300(c)Y +4212(c)Y +4124(c)Y +4036(c)Y +3948(c)Y +3860(c)Y +3772(c)Y +3684(c)Y +3596(c)Y +3508(c)Y +3420(c)Y +2586 4668(c)N +4652(c)Y +4564(c)Y +4476(c)Y +4388(c)Y +4300(c)Y +4212(c)Y +4124(c)Y +4036(c)Y +3948(c)Y +3860(c)Y +3772(c)Y +3684(c)Y +3596(c)Y +3508(c)Y +3420(c)Y +2969 4668(c)N +4652(c)Y +4564(c)Y +4476(c)Y +4388(c)Y +4300(c)Y +4212(c)Y +4124(c)Y +4036(c)Y +3948(c)Y +3860(c)Y +3772(c)Y +3684(c)Y +3596(c)Y +3508(c)Y +3420(c)Y +1 f +1436 4828(Table)N +1659(3)X +1725(:)X +1772(Barrier)X +2043(synchronization)X +2628(timings)X +2916(in)X +3 f +9 s +3007(PVM)X +11 s +576 5276(4.2.)N +752(Example)X +1107(Applications)X +1 f +776 5416(In)N +871(order)X +1078(to)X +1169(compare)X +1494(the)X +1624(relative)X +1912(performance)X +2379(of)X +2475(the)X +3 f +9 s +2602(PVM)X +1 f +11 s +2789(system)X +3057(to)X +3149(existing)X +3452(multiprocessors,)X +576 5528(two)N +733(existing)X +1038(parallel)X +1328(codes)X +1553(were)X +1748(ported)X +1998(to)X +2092(run)X +2234(on)X +2347(the)X +2480(system.)X +2772(These)X +3006(two)X +3162(applications)X +3613(were)X +3807(ported)X +576 5640(without)N +881(any)X +1043(changes)X +1361(to)X +1466(the)X +1610(algorithm)X +1990(itself,)X +2225(and)X +2388(were)X +2594(executed)X +2943(under)X +3 f +9 s +3175(PVM)X +1 f +11 s +3375(on)X +3499(a)X +3574(collection)X +3959(of)X +576 5752(homogeneous)N +1092(machines.)X +1474(The)X +1638(\256rst)X +1802(application)X +2222(was)X +2385(numerical)X +2764(integration)X +3173(using)X +3390(the)X +3524(rectangle)X +3873(rule.)X +576 5864(The)N +736(results)X +989(from)X +1184(this)X +1336(experiment)X +1757(were)X +1951(uninterestingly)X +2505(predictable;)X +2946(on)X +3 f +9 s +3054(PVM)X +1 f +11 s +3218(,)X +3264(scaling)X +3538(in)X +3631(the)X +3763(number)X + +19 p +%%Page: 19 19 +11 s 11 xH 0 xS 1 f +2209 400(-)N +2260(19)X +2370(-)X +576 688(of)N +673(processors)X +1067(or)X +1164(the)X +1296(number)X +1589(of)X +1686(rectangles)X +2067(resulted)X +2370(in)X +2462(a)X +2524(linear)X +2748(performance)X +3215(increase.)X +3570(Furthermore,)X +576 800(the)N +709(performance)X +1178(ratio)X +1365(between)X +3 f +9 s +1679(PVM)X +1 f +11 s +1868(and)X +2020(the)X +2153(iPSC/2)X +2429(multiprocessor)X +2978(for)X +3105(this)X +3258(problem)X +3577(was)X +3738(constant)X +576 912(\320)N +689(and)X +840(consistent)X +1217(with)X +1398(the)X +1530(inherent)X +1843(processor)X +2203(speed)X +2427(differences.)X +2863(The)X +3024(second)X +3292(application)X +3709(is)X +3792(Chole-)X +576 1024(sky)N +724(matrix)X +981(factorization)X +1453([16])X +1625(\320)X +1739(an)X +1848(application)X +2267(that)X +2426(has)X +2569(a)X +2634(relatively)X +2994(high)X +3178(communication)X +3755(to)X +3851(com-)X +576 1136(putation)N +896(ratio.)X +1132(Table)X +1363(4)X +1437(shows)X +1686(the)X +1824(elapsed)X +2118(times)X +2340(for)X +2472(this)X +2630(problem)X +2954(run)X +3101(on)X +3219(a)X +3288(network)X +3606(of)X +3709(Sun)X +3875(3/50)X +576 1248(machines)N +952(for)X +1098(varying)X +1411(problem)X +1749(sizes.)X +1986(Shown)X +2274(in)X +2387(parentheses)X +2841(adjacent)X +3179(to)X +3292(each)X +3497(timing)X +3773(are)X +3924(the)X +576 1360(corresponding)N +1106(times)X +1325(for)X +1454(running)X +1755(the)X +1890(same)X +2098(program)X +2423(on)X +2538(an)X +2648(Intel)X +2837(iPSC/2)X +3115(hypercube.)X +3530(In)X +3629(this)X +3783(experi-)X +576 1472(ment,)N +808(no)X +929(attempt)X +1228(was)X +1397(made)X +1621(to)X +1723(place)X +1942(more)X +2156(than)X +2341(one)X +2501(component)X +2926(process)X +3223(on)X +3345(a)X +3418(host;)X +3624(however,)X +3982(it)X +576 1584(should)N +838(be)X +948(noted)X +1171(that)X +1331(each)X +1519(participating)X +1993(host)X +2167(was)X +2330(also)X +2499(being)X +2722(used)X +2910(simultaneously)X +3472(for)X +3601(general)X +3886(pur-)X +576 1696(pose)N +759(editing,)X +1049(compilation,)X +1516(and)X +1665(other)X +1868(normal)X +2140(workstation)X +2578(activities.)X +10 f +936 1888(i)N +944(iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii)X +1 f +1053 2000(No.)N +1204(of)X +2005(Problem)X +2326(size)X +2485(\(Order)X +2740(of)X +2835(Matrix\))X +980 2112(processors)N +1610(100)X +2119(200)X +2661(500)X +3269(1000)X +10 f +936 2128(i)N +944(iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii)X +936 2144(i)N +944(iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii)X +1 f +1165 2248(2)N +1526(6)X +1702(\(2\))X +2002(35)X +2222(\(30\))X +2500(260)X +2764(\(245\))X +3086(1950)X +3394(\(1923\))X +10 f +936 2272(i)N +944(iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii)X +1 f +1165 2384(4)N +1526(7)X +1702(\(2\))X +2002(22)X +2222(\(16\))X +2500(130)X +2764(\(120\))X +3130(990)X +3438(\(970\))X +10 f +936 2408(i)N +944(iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii)X +1 f +1165 2520(8)N +1526(9)X +1702(\(1.5\))X +2002(17)X +2266(\(9\))X +2544(75)X +2808(\(64\))X +3130(610)X +3438(\(490\))X +10 f +936 2544(i)N +944(iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii)X +1 f +1121 2656(16)N +1482(14)X +1702(\(1\))X +2002(12)X +2266(\(6\))X +2544(46)X +2808(\(34\))X +3130(342)X +3438(\(255\))X +10 f +936 2680(i)N +944(iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii)X +936(c)X +2592(c)Y +2504(c)Y +2416(c)Y +2328(c)Y +2240(c)Y +2152(c)Y +2064(c)Y +1976(c)Y +1416 2680(c)N +2592(c)Y +2504(c)Y +2416(c)Y +2328(c)Y +2240(c)Y +2152(c)Y +2064(c)Y +1976(c)Y +1936 2680(c)N +2672(c)Y +2584(c)Y +2496(c)Y +2408(c)Y +2320(c)Y +2232(c)Y +2434 2680(c)N +2672(c)Y +2584(c)Y +2496(c)Y +2408(c)Y +2320(c)Y +2232(c)Y +3020 2680(c)N +2672(c)Y +2584(c)Y +2496(c)Y +2408(c)Y +2320(c)Y +2232(c)Y +3672 2680(c)N +2592(c)Y +2504(c)Y +2416(c)Y +2328(c)Y +2240(c)Y +2152(c)Y +2064(c)Y +1976(c)Y +1 f +1327 2840(Table)N +1550(4)X +1616(:)X +1663(Times)X +1906(\(in)X +2026(seconds\))X +2355(for)X +2479(Cholesky)X +2834(factorization)X +776 3204(The)N +941(anomaly)X +1273(apparent)X +1605(in)X +1703(the)X +1840(\256rst)X +2006(column)X +2300(of)X +2402(Table)X +2632(4)X +2705(was)X +2870(traced)X +3114(down)X +3338(to)X +3436(the)X +3573(nature)X +3822(of)X +3924(the)X +576 3316(Cholesky)N +935(algorithm)X +1305(\320)X +1419(for)X +1547(a)X +1612(small)X +1830(matrix,)X +2109(the)X +2243(simultaneous)X +2735(broadcasts)X +3132(of)X +3230(every)X +3450(process's)X +3801(matrix)X +576 3428(column)N +877(to)X +983(a)X +1059(\(relatively\))X +1488(large)X +1701(number)X +2007(of)X +2117(processors)X +2524(resulted)X +2840(in)X +2946(a)X +3022(high)X +3216(percentage)X +3634(of)X +3744(dropped)X +576 3540(packets,)N +889(leading)X +1176(to)X +1272(retransmissions)X +1846(and)X +1999(elapsed)X +2289(timeouts.)X +2642(For)X +2790(larger)X +3021(problems)X +3375(however,)X +3725(it)X +3801(can)X +3949(be)X +576 3652(seen)N +760(that)X +921(the)X +1057(performance)X +1529(of)X +3 f +9 s +1626(PVM)X +1 f +11 s +1818(is)X +1905(acceptable)X +2305(at)X +2397(the)X +2533(least,)X +2745(considering)X +3184(that)X +3346(the)X +3483(application)X +3905(is)X +3993(a)X +576 3764(substantially)N +1051(communication)X +1629(oriented)X +1945(one)X +2099(and)X +2253(that)X +2413(general)X +2699(purpose)X +3004(machines)X +3364(on)X +3479(a)X +3545(local)X +3744(network)X +576 3876(were)N +775(used.)X +987(It)X +1070(should)X +1334(also)X +1505(be)X +1617(pointed)X +1911(out)X +2053(that)X +2215(these)X +2426(\256gures)X +2695(are)X +2832(2)X +2906(to)X +3005(4)X +3079(times)X +3301(better)X +3532(than)X +3714(those)X +3930(for)X +576 3988(other)N +787(distributed)X +1194(multiprocessor)X +1747(simulators)X +2144(such)X +2334(as)X +2436(dsim[5].)X +2783(Furthermore,)X +3274(the)X +3411(factorization)X +3886(pro-)X +576 4100(gram)N +794(was)X +967(built)X +1167(for)X +1307(performance)X +1789(measurement)X +2297(purposes)X +2647(and)X +2812(therefore)X +3167(internally)X +3544(generated)X +3924(the)X +576 4212(matrix)N +858(elements)X +1223(and)X +1401(did)X +1565(not)X +1729(output)X +2006(the)X +2165(factorized)X +2568(results.)X +2871(Given)X +3137(the)X +3295(usual)X +3531(dif\256culty)X +3905(and)X +576 4324(inef\256ciencies)N +1074(in)X +1172(I/O)X +1318(from)X +1518(within)X +1773(the)X +1910(nodes)X +2144(in)X +2242(a)X +2310(distributed)X +2717(memory)X +3040(machine,)X +3390(it)X +3469(is)X +3557(expected)X +3899(that)X +3 f +9 s +576 4436(PVM)N +1 f +11 s +785(will)X +968(compare)X +1316(much)X +1557(more)X +1783(favorably)X +2164(against)X +2458(hardware)X +2828(multiprocessors)X +3430(when)X +3664(signi\256cant)X +576 4548(amounts)N +897(of)X +992(I/O)X +1131(are)X +1260(performed.)X +3 f +576 4884(5.)N +686(Application)X +1149(Experiences)X +1 f +776 5136(The)N +3 f +9 s +937(PVM)X +1 f +11 s +1129(system)X +1402(has)X +1547(evolved)X +1854(and)X +2009(has)X +2154(been)X +2348(in)X +2445 0.3182(intermittent)AX +2887(use)X +3033(for)X +3164(the)X +3301(past)X +3472(several)X +3750(months,)X +576 5248(and)N +730(enhancements)X +1256(are)X +1390(still)X +1551(ongoing.)X +1889(Several)X +2180(application)X +2599(codes)X +2825(have)X +3017(been)X +3209(ported)X +3460(to)X +3555(run)X +3698(under)X +3924(the)X +3 f +9 s +576 5360(PVM)N +1 f +11 s +762(environment;)X +1255(in)X +1346(this)X +1496(section,)X +1790(two)X +1944(applications)X +2393(that)X +2549(make)X +2763(extensive)X +3119(use)X +3259(of)X +3355(the)X +3486(system)X +3754(features)X +576 5472(are)N +705(described.)X + +20 p +%%Page: 20 20 +11 s 11 xH 0 xS 1 f +2209 400(-)N +2260(20)X +2370(-)X +3 f +576 688(5.1.)N +752(Block)X +990(Matrix)X +1276(Multiplication)X +1 f +776 940(Matrix)N +1046 0.3365(multiplication)AX +1574(is)X +1663(a)X +1732(compute)X +2066(intensive)X +2415(application)X +2838(that)X +3001(is)X +3091(amenable)X +3460(to)X +3560(parallel)X +3856(solu-)X +576 1052(tion.)N +767(On)X +905(shared)X +1165(memory)X +1489(multiprocessors,)X +2099(prescheduling)X +2623(algorithms)X +3031(work)X +3241(well)X +3423(and)X +3580(exhibit)X +3856(good)X +576 1164(speedup)N +901(characteristics)X +1442(with)X +1636(an)X +1756(increase)X +2081(in)X +2187(the)X +2332(number)X +2638(of)X +2748(processors.)X +3177(On)X +3322(distributed)X +3738(memory)X +576 1276(machines,)N +957(matrices)X +1282(are)X +1415(decomposed)X +1881(into)X +2045(subblocks)X +2423(and)X +2576 0.3875(multiplied;)AX +2992(and)X +3144(a)X +3208(regular)X +3482(communication)X +576 1388(pattern)N +855(between)X +1182(the)X +1324(processing)X +1734(elements)X +2082(helps)X +2302(minimize)X +2671(the)X +2814(overheads.)X +3227(A)X +3325(detailed)X +3640(description)X +576 1500(and)N +725(analysis)X +1031(of)X +1126(block)X +1344(matrix)X +1597 0.3365(multiplication)AX +2117(on)X +2227(hypercube)X +2615(architectures)X +3087(may)X +3261(be)X +3366(found)X +3593(in)X +3684([18].)X +776 1752(A)N +870(modi\256ed)X +1215(version)X +1505(of)X +1609(the)X +1748(block)X +1975(matrix)X +2237 0.3365(multiplication)AX +2766(algorithm)X +3142(was)X +3310(implemented)X +3804(on)X +3924(the)X +3 f +9 s +576 1864(PVM)N +1 f +11 s +768(system)X +1041(and)X +1196(executed)X +1537(on)X +1653(various)X +1940(hardware)X +2294(combinations.)X +2820(The)X +2985(modi\256cation)X +3460(was)X +3624(with)X +3808(regard)X +576 1976(to)N +672(subblock)X +1017(decomposition;)X +1590(when)X +1808(the)X +1944(individual)X +2331(processors)X +2729(differ)X +2952(widely)X +3220(in)X +3317(computing)X +3723(capabili-)X +576 2088(ties,)N +752(equal)X +974(sized)X +1186(subblocks)X +1569(lead)X +1746(to)X +1845(severe)X +2099(load)X +2281(imbalances)X +2708(and)X +2865(result)X +3091(in)X +3190(signi\256cant)X +3588(performance)X +576 2200(degradation.)N +1040(To)X +1164(overcome)X +1538(this,)X +1715(the)X +1850(matrices)X +2176(to)X +2272(be)X +2382 0.3681(multiplied)AX +2774(were)X +2971(viewed)X +3252(as)X +3352(being)X +3575(composed)X +3959(of)X +576 2312(small,)N +814(equal)X +1029(sized)X +1234(subblocks)X +1610(\320)X +1722(with)X +1903(individual)X +2286(processors)X +2680(taking)X +2924(responsibility)X +3428(for)X +2 f +3553(collections)X +1 f +3959(of)X +576 2424(subblocks)N +965(at)X +1066(a)X +1142(time,)X +1359(the)X +1504(size)X +1678(of)X +1789(the)X +1935(collections)X +2356(being)X +2590(determined)X +3025(by)X +3151(their)X +3351(relative)X +3654(computing)X +576 2536(power.)N +852(In)X +960(other)X +1176(words,)X +1447(the)X +1590(algorithm)X +1969(was)X +2140(expressed)X +2521(using)X +2747(the)X +2890("bag)X +3087(of)X +3194(tasks")X +3440(approach,)X +3818(where)X +576 2648(each)N +783(task)X +971(is)X +1076(individual)X +1481(subblock)X +1846 0.3125(multiplication.)AX +2413(However,)X +2803(each)X +3011(worker)X +3306(process)X +3616(extracts,)X +3959(or)X +576 2760(assumes)N +893(responsibility)X +1398(for,)X +1546(a)X +1609(number)X +1902(of)X +1999(tasks)X +2199(at)X +2287(a)X +2350(time)X +2531(to)X +2623(reduce)X +2880(synchronization)X +3466(and)X +3616(cooperation)X +576 2872(overheads.)N +576 3012 MXY +3672 +2966 +0.00 +0.00 +459.00 +370.80 +startFig +%! +%%%Creator: vss@mathsund (V.S.Sunderam,216 Fishburne,7275926,2974135) +%%%Title: fig7 (xpic) +%%%CreationDate: Fri Mar 23 13:10:10 1990 +%%%Pages: 1 +%%%BoundingBox: 0 0 459 370.8 +%% (in inches) at 0 0, width 6.375, height 5.15 +%%%EndComments +%% Prolog for xpic to PostScript converter +%% Author: Mark Moraes +%% $Header: x2ps.pro,v 1.2 88/03/19 16:50:09 moraes Exp +%% %d D - change style SOLID, DOTTED, SHORT-DASH, LONG-DASH, DOT-DASH +%% %s F - change font to fontname +%% %d S - change size (font size in points) +%% (%s) rj %d t - text right just. (%d is TOPLINE, MIDLINE, BOTLINE) +%% (%s) lj %d t - text left just. (%d is TOPLINE, MIDLINE, BOTLINE) +%% (%s) ce %d t - text centered (%d is TOPLINE, MIDLINE, BOTLINE) +%% %d %d l - lineto +%% %d %d m - moveto +%% %d %d s - spline segment +%% x - flush line, spline +%% <wid> <ht> <x> <y> b - box +%% <wid> <ht> <x> <y> e - ellipse +%% %d ss - setscale +%% %d W - change linewidth +%% getpagesize - gets the values of PAGEHEIGHT and PAGEWIDTH +%% %d %d flip - translate by %d, PAGEHEIGHT - %d (this +%% transforms to X windows coordinates) +save 50 dict begin /xpic exch def +/StartXpic {newpath 0 0 moveto [] 0 setdash 0 setgray 1 setlinecap} def +%% Set defaults +/fontname /Times-Roman def +/ptsize 12 def +%% halign has the values for MIDLINE, TOPLINE, BOTLINE +/halign 3 array def +/s {rcurveto} def +/x {stroke} def +/l {lineto} def +/m {moveto} def +/b { + /ury exch def /urx exch def /lly exch def /llx exch def + llx lly moveto urx lly lineto urx ury lineto + llx ury lineto llx lly lineto stroke +} def +/mtrx matrix def +/e { + /yc exch def /xc exch def /yrad exch def /xrad exch def + xc xrad add yc moveto + /savematrix mtrx currentmatrix def + xc yc translate + xrad yrad scale + 0 0 1 0 360 arc + savematrix setmatrix stroke +} def +%% The next three take the text string, and moveto the right horiz. position +%% leaving the string on the stack. +/lj {} def +/rj {dup stringwidth pop neg 0 rmoveto} def +/ce {dup stringwidth pop 2 div neg 0 rmoveto} def +%% And this is invoked after one of the three above, and +%% computes the vert. pos, and then displays the string. +/t {halign exch get 0 exch rmoveto show newpath} def +%% Store an array of patterns in /styles - a pattern is an array consisting +%% of an array and an offset. Corresp to xpic patterns +%% solid, dotted, short-dashed, long-dashed, dot-dashed +/styles [ [] 0 ] [ [1 3] 0 ] [ [4 4] 0 ] [ [8 4] 0 ] [ [1 4 4 4] 0 ] + 5 array astore def +%% change style to arg. +/D {stroke styles exch get aload pop setdash newpath} def +/W {stroke 0.5 mul setlinewidth newpath} def +%% fontbox takes a fontname off the stack, and returns an array +%% containing the values of the bottom line of the bounding box, the +%% mid line of the bounding box, and the top line of the bounding box +%% of that font, taken from the baseline, scaled to a font of size 1 +/fontbox { + findfont dup /FontMatrix get /fm exch def /FontBBox get aload pop + /ytop exch def pop /ybot exch def pop + /ymid ytop ybot sub 2 div def + 0 ybot fm dtransform exch pop % botline + dup neg exch % midline - this works better than (ytop-ybot)/2! + 0 ytop fm dtransform exch pop exch %topline + % now in the order midline, topline, botline. + 3 array astore +} def +%% select font +/F { + dup /fontname exch def fontbox + /thisfontbox exch def SF +} def +%% set point size +/S {/ptsize exch def SF} def +%% actually set font +/SF { + fontname findfont ptsize curscale div scalefont setfont + thisfontbox aload pop + 1 1 3 { + pop ptsize mul curscale div neg 3 1 roll + } for + halign astore pop +} def +%% sets the scale to 72 / n, where n is on the stack, and stores the value +%% in curscale for font scaling +/curscale 1 def +/getpagesize{newpath clippath pathbbox /pageheight exch def + /pagewidth exch def pop pop newpath} def +/flip{pageheight exch sub translate} def +/ss {/curscale exch 72 exch div dup dup scale def} def +/land {90 rotate} def +StartXpic +%%%EndProlog +80 ss +0.5 W +/Times-Roman F +10 S +92 27 m +(for result matrix subblock computations) ce 0 t +84 43 m +(-Heavy boxes show actual allocation) ce 0 t +76 59 m +(- Dashed grid shows decomposition) ce 0 t +324 43 m +(-) ce 0 t +420 43 m +(Bands in A and B are similarly identified) ce 0 t +388 59 m +(-Each Cn is a 64x512 "band") ce 0 t +2 D +76 195 m +396 195 l +x +76 235 m +396 235 l +x +76 275 m +396 275 l +x +76 355 m +396 355 l +x +76 315 m +396 315 l +x +84 155 m +404 155 l +x +2 W +0 D +76 395 156 315 b +156 315 316 155 b +0.5 W +76 395 396 75 b +2 D +116 395 m +116 75 l +x +156 75 m +156 395 l +x +196 395 m +196 75 l +x +236 395 m +236 75 l +x +276 387 m +276 75 l +x +316 387 m +316 75 l +x +76 115 m +396 115 l +x +2 W +0 D +316 155 396 75 b +156 355 316 315 b +156 395 316 355 b +76 155 316 75 b +316 395 396 155 b +0.5 W +236 243 m +(16-node hypercube) ce 0 t +116 363 m +(4 Sun 3/50) ce 0 t +188 123 m +(12-processor Sequent) ce 0 t +356 259 m +(Sequent) ce 0 t +356 123 m +(Sun 4/280) ce 0 t +236 371 m +(Sun 3/60 #1) ce 0 t +236 331 m +(Sun 3/60 #2) ce 0 t +156 43 m +(-) ce 0 t +76 403 m +(0) ce 0 t +68 395 m +(0) ce 0 t +60 75 m +(511) ce 0 t +396 403 m +(511) ce 0 t +/Times-Italic F +436 387 m +(Shared data ) ce 0 t +436 379 m +(structure C1) ce 0 t +420 331 m +(C2) ce 0 t +420 299 m +(C3) ce 0 t +420 251 m +(C4) ce 0 t +420 211 m +(C5) ce 0 t +420 179 m +(C6) ce 0 t +420 139 m +(C7) ce 0 t +100 403 m +(Ca) ce 0 t +140 403 m +(Cb) ce 0 t +180 403 m +(Cc) ce 0 t +220 403 m +(Cd) ce 0 t +260 403 m +(Ce) ce 0 t +292 403 m +(Cf) ce 0 t +332 403 m +(Cg) ce 0 t +372 403 m +(Ch) ce 0 t +420 99 m +(C8) ce 0 t +2 W +76 315 156 155 b +0.5 W +/Times-Roman F +116 243 m +(Vax) ce 0 t +12 S +252 3 m +(Figure 7: Asymteric decomposition for matrix multiplication) ce 0 t +2 D +356 387 m +356 75 l +x +%%%Trailer +showpage +%% Trailer for xpic to PostScript converter +%% $Header: x2ps.tra,v 1.1 88/08/31 23:48:01 moraes Exp $ +xpic end restore +endFig + +21 p +%%Page: 21 21 +11 s 11 xH 0 xS 1 f +2209 400(-)N +2260(21)X +2370(-)X +776 688(Figure)N +1029(7)X +1096(shows)X +1338(an)X +1444(example)X +1766(scenario,)X +2104(where)X +2341(task)X +2506(partitioning)X +2941(is)X +3022(shown)X +3273(in)X +3364(terms)X +3582(of)X +3677(the)X +3807(result-)X +576 800(ing)N +715(matrix.)X +1017(It)X +1098(should)X +1360(be)X +1470(noted)X +1693(that)X +1853(the)X +1988(decomposition)X +2535(shown)X +2791(in)X +2887(the)X +3022(\256gure)X +3254(is)X +3340(not)X +3480(statically)X +3827(deter-)X +576 912(mined;)N +858(each)X +1055(processor)X +1427(computes)X +1801(one)X +1964(subblock)X +2317(aggregate,)X +2716(then)X +2903(obtains)X +3193(another,)X +3514(and)X +3676(so)X +3789(on.)X +3934(To)X +576 1024(implement)N +977(this)X +1127(on)X +3 f +9 s +1233(PVM)X +1 f +11 s +1397(,)X +1441(the)X +1571(following)X +1936(strategy)X +2237(was)X +2395(used:)X +576 1164(-)N +776(The)X +939(matrices)X +1264(to)X +1359(be)X +1468 0.3681(multiplied)AX +1859(\()X +2 f +1888(A)X +1 f +1968(and)X +2 f +2121(B)X +1 f +2175(\))X +2231(are)X +2365(maintained)X +2785(in)X +2881(emulated)X +3232(shared)X +3488(memory)X +3809(by)X +3924(the)X +776 1276("startup")N +1145(process,)X +1487(with)X +1701(each)X +1919(subblock)X +2294(row)X +2487(and)X +2671(column)X +2993(\(band\))X +3279(being)X +3532(independently)X +776 1388(identi\256able)N +1196(as)X +1291(shown)X +1542(in)X +1633(Figure)X +1885(7.)X +1973(The)X +2132(granularity)X +2541(of)X +2636(sharing)X +2917(is)X +2998(therefore)X +3337(large.)X +576 1528(-)N +776(System)X +1060(component)X +1476(programs)X +1832(are)X +1963(written)X +2237(to)X +2330(use)X +2471(the)X +2604(algorithm)X +2973(most)X +3170(appropriate)X +3596(for)X +3723(their)X +3910(tar-)X +776 1640(geted)N +1033(architecture,)X +1537(i.e.)X +1710(a)X +1814(square)X +2108(subblock)X +2491(component)X +2948(for)X +3115(the)X +3288(hypercube,)X +3741(a)X +3845(static)X +776 1752(prescheduled)N +1279(component)X +1710(for)X +1851(the)X +1998(Sequent)X +2321(shared)X +2589(memory)X +2922(multiprocessor,)X +3507(and)X +3674(sequential)X +776 1864(code)N +964(for)X +1088(the)X +1218(Sun)X +1377(workstations.)X +576 2004(-)N +776(A)X +861("working)X +1212(list")X +1379(shared)X +1630(data)X +1799(structure)X +2129(is)X +2210(set)X +2330(up,)X +2462(once)X +2650(again)X +2863(by)X +2973(the)X +3103("startup")X +3437(process.)X +3744(This)X +3923(list)X +776 2116(holds)N +991(the)X +1123(result)X +1343(matrix)X +1598(subblocks)X +1974(that)X +2130(have)X +2319(been)X +2508(computed)X +2879(or)X +2975(have)X +3164(been)X +3353(taken)X +3567(up)X +3678(by)X +3789(a)X +3851(com-)X +776 2228(ponent.)N +1065(For)X +1214(example,)X +1562(when)X +1779(all)X +1895(but)X +2035(the)X +2170(bottom)X +2448(right)X +2642(corner)X +2893(subblock)X +3238(of)X +2 f +3338(C)X +1 f +3424(\(Fig.)X +3620(7\))X +3721(has)X +3866(been)X +776 2340(computed)N +1146(the)X +1276(list)X +1407(might)X +1636(contain:)X +776 2480(+)N +976({0,127},{0,127})X +1584(:)X +1631(Indicating)X +2011(that)X +2167(the)X +2298(4-member)X +2683(group)X +2911(of)X +3007(Sun)X +3167(3/50's)X +3410(\(using)X +3 f +9 s +3649(PVM)X +1 f +11 s +3836(prim-)X +976 2592(itives)N +1205(to)X +1311(cooperate)X +1690(using)X +1918(message-passing\))X +2575(had)X +2739(taken)X +2966(responsibility)X +3483(for)X +3621(the)X +3765(top)X +3914(left)X +976 2704(corner)N +1222(subblock.)X +776 2844(+)N +976({128,383},{0,63})X +1628(:)X +1675(Taken)X +1917(\(and)X +2095(perhaps)X +2390(completed\))X +2809(by)X +2919(Sun)X +3078(3/60)X +3257(#1.)X +776 2984(+)N +976({128,383},{65,127})X +1716(:)X +1763(Taken)X +2005(by)X +2115(Sun)X +2274(3/60)X +2453(#2.)X +776 3124(+)N +976({384,511},{0,383})X +1672(:)X +1719(Taken)X +1961(by)X +2071(and)X +2220(completed)X +2610(by)X +2720(the)X +2850(Sequent.)X +776 3264(+)N +976({0,127},{128,383})X +1672(:)X +1719(Taken)X +1961(by)X +2071(Vax.)X +776 3404(+)N +976({0,383},{384,511})X +1672(:)X +1719(Taken)X +1961(by)X +2071(Sequent)X +2377(and)X +2526(perhaps)X +2821(being)X +3039(currently)X +3379(processed.)X +776 3516(The)N +942(last)X +1094(processor,)X +1481(upon)X +1686(inspecting)X +2078(this)X +2235(list,)X +2395(determines)X +2811(that)X +2973(it)X +3052(can)X +3203(compute)X +3536(the)X +3674(remaining)X +776 3628(subblock)N +1120(\({384,511},{384,511}\),)X +1988(and)X +2140(enters)X +2375(this)X +2528(pair)X +2690(in)X +2784(the)X +2917(list)X +3051(-)X +3105(thereby)X +3394(signaling)X +3743(comple-)X +776 3740(tion)N +936(to)X +1027(other)X +1230(processors.)X +576 3880(-)N +776(Having)X +1071(determined)X +1504(which)X +1755(subblock)X +2110(a)X +2186(component)X +2615(was)X +2788(going)X +3026(to)X +3132(compute,)X +3495(the)X +3640(component)X +776 3992(then)N +958(maps)X +1174(the)X +1312(appropriate)X +1743(segments)X +2101(of)X +2204(the)X +2 f +2341(A)X +1 f +2424(and)X +2 f +2580(B)X +1 f +2663(matrices)X +2991(into)X +3158(its)X +3271(local)X +3472(memory.)X +3817(Again)X +776 4104(using)N +998(\256gure)X +1234(7)X +1309(as)X +1413(an)X +1527(example,)X +1879(the)X +2019(component)X +2443(executing)X +2818(on)X +2938("Sun)X +3143(3/60)X +3332(#2")X +3488(would)X +3740(map)X +3924(the)X +776 4216(bands)N +1005(A2)X +1136(and)X +1287(Bb-Bf)X +1531(into)X +1693(its)X +1801(local)X +1997(memory,)X +2337(and)X +2488(using)X +2702(these,)X +2928(would)X +3171(compute)X +3498(the)X +3629(shown)X +3881(sub-)X +776 4328(block)N +998(of)X +1097(the)X +1232(matrix)X +2 f +1490(C)X +1 f +1549(.)X +1598(The)X +1762(Sequent)X +2073(\(in)X +2198(one)X +2352(case\))X +2559(would)X +2806(map)X +2985(bands)X +3217(A7-A8)X +3487(and)X +3641(Ba-Bf,)X +3905(and)X +776 4440(use)N +915(a)X +976(locally)X +1239(parallel)X +1526(program)X +1846(to)X +1937(compute)X +2263(the)X +2393(resulting)X +2724(matrix)X +2977(subblock.)X +776 4804(The)N +941(results)X +1199(of)X +1300(executing)X +1672(this)X +1829(asymmetric)X +2270(algorithm)X +2643(using)X +2863(multiple)X +3188(architectures)X +3667(are)X +3803(shown)X +576 4916(in)N +680(Table)X +916(5.)X +1017(Also)X +1218(shown)X +1482(are)X +1624(the)X +1766(timing)X +2032(\256gures)X +2305(for)X +2441 0.3375(multiplying)AX +2889(the)X +3031(same)X +3246(matrices)X +3579(using)X +3804("pure")X +576 5028(algorithms)N +978(on)X +1090(a)X +1153(hypercube)X +1543(and)X +1694(a)X +1757(shared)X +2010(memory)X +2328(machine.)X +2695(It)X +2773(can)X +2919(be)X +3026(seen)X +3207(from)X +3403(the)X +3536(\256gure)X +3766(that)X +3924(the)X +3 f +9 s +576 5140(PVM)N +1 f +11 s +776 0.2885(implementation)AX +1368(scales)X +1614(well,)X +1824(even)X +2026(for)X +2163(a)X +2237(heterogeneous)X +2780(collection)X +3164(of)X +3272(processors,)X +3699(when)X +3924(the)X +576 5252(matrices)N +899(are)X +1030(large.)X +1252(For)X +1398(smaller)X +1682(matrices)X +2005(however,)X +2353(the)X +2485(locking)X +2774(and)X +2925(emulated)X +3274(shared)X +3528(memory)X +3847(over-)X +576 5364(heads)N +803(actually)X +1110(cause)X +1332(an)X +2 f +1442(increase)X +1 f +1767(in)X +1862(execution)X +2231(times)X +2449(when)X +2665(more)X +2872(processors)X +3268(are)X +3401(added.)X +3681(Neverthe-)X +576 5476(less,)N +760(it)X +841(is)X +931(felt)X +1080(that)X +1244(such)X +1436(algorithms)X +1845(are)X +1983(valuable)X +2313(for)X +2446(two)X +2609(important)X +2984(reasons.)X +3300(First,)X +3515(when)X +3736(multiple)X +576 5588(processors)N +970(are)X +1101(available,)X +1466(the)X +1598(total)X +1780(computing)X +2182(power)X +2425(can)X +2571(be)X +2677(increased)X +3032(\320)X +3143(e.g.)X +3293(a)X +3355(16-node)X +3666(hypercube)X +576 5700(may)N +773(be)X +901(combined)X +1294(with)X +1496(other)X +1722(processors)X +2137(to)X +2251(emulate)X +2576(a)X +2660(32)X +2793(processor)X +3174(virtual)X +3450(machine)X +3794(that)X +3973(is)X +576 5812(bene\256cial)N +950(for)X +1083(large)X +1290(matrices.)X +1642(Second,)X +1954(the)X +2093(the)X +2232(support)X +2526(services)X +2839(that)X +3002(are)X +3139(available)X +3488(on)X +3606(the)X +3744(network)X + +22 p +%%Page: 22 22 +11 s 11 xH 0 xS 1 f +2209 400(-)N +2260(22)X +2370(-)X +10 f +1327 656(iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii)N +1 f +1448 768(Machine)N +1965(No.)X +2116(of)X +2322(Problem)X +2643(Size)X +2817(\(Order)X +3072(of)X +3167(Matrix\))X +1526 880(type)N +1971(procs.)X +2334(64)X +2580(128)X +2892(256)X +3248(512)X +10 f +1327 896(iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii)N +1327 912(iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii)N +1 f +1460 1016(Sequent)N +2055(4)X +2323(5.4)X +2569(40.5)X +2859(326.6)X +3193(2581.9)X +10 f +1327 1040(iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii)N +1 f +1460 1152(Sequent)N +2055(8)X +2323(2.9)X +2569(20.9)X +2859(163.8)X +3193(1292.7)X +10 f +1327 1168(iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii)N +1327 1184(iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii)N +1 f +1476 1288(iPSC/2)N +2055(4)X +2323(1.5)X +2613(9.3)X +2903(81.5)X +3237(693.5)X +10 f +1327 1312(iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii)N +1 f +1476 1424(iPSC/2)N +2033(16)X +2323(1.2)X +2613(3.1)X +2903(18.2)X +3237(191.7)X +10 f +1327 1440(iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii)N +1327 1456(iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii)N +1 f +1381 1560(PVM)N +1593(\(Suns\))X +2055(4)X +2323(1.8)X +2613(4.3)X +2903(26.5)X +3237(231.6)X +10 f +1327 1584(iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii)N +1 f +1371 1696(PVM)N +1583(\(Suns+)X +1409 1808(Sequent-8\))N +2033(16)X +2323(2.8)X +2613(5.1)X +2903(20.3)X +3237(212.5)X +10 f +1327 1832(iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii)N +1 f +1382 1944(PVM\(Suns+)N +1398 2056(Sequent-8+)N +2033(32)X +2323(3.5)X +2613(7.2)X +2903(16.6)X +3237(130.8)X +1403 2168(iPSC/2-16\))N +10 f +1327 2192(iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii)N +1327(c)X +2152(c)Y +2064(c)Y +1976(c)Y +1888(c)Y +1800(c)Y +1712(c)Y +1624(c)Y +1536(c)Y +1448(c)Y +1360(c)Y +1272(c)Y +1184(c)Y +1096(c)Y +1008(c)Y +920(c)Y +832(c)Y +744(c)Y +1899 2192(c)N +2152(c)Y +2064(c)Y +1976(c)Y +1888(c)Y +1800(c)Y +1712(c)Y +1624(c)Y +1536(c)Y +1448(c)Y +1360(c)Y +1272(c)Y +1184(c)Y +1096(c)Y +1008(c)Y +920(c)Y +832(c)Y +744(c)Y +2255 2192(c)N +2152(c)Y +2064(c)Y +1976(c)Y +1888(c)Y +1800(c)Y +1712(c)Y +1624(c)Y +1536(c)Y +1448(c)Y +1360(c)Y +1272(c)Y +1184(c)Y +1096(c)Y +1008(c)Y +920(c)Y +832(c)Y +744(c)Y +2501 2192(c)N +2144(c)Y +2056(c)Y +1968(c)Y +1880(c)Y +1792(c)Y +1704(c)Y +1616(c)Y +1528(c)Y +1440(c)Y +1352(c)Y +1264(c)Y +1176(c)Y +1088(c)Y +1000(c)Y +2791 2192(c)N +2144(c)Y +2056(c)Y +1968(c)Y +1880(c)Y +1792(c)Y +1704(c)Y +1616(c)Y +1528(c)Y +1440(c)Y +1352(c)Y +1264(c)Y +1176(c)Y +1088(c)Y +1000(c)Y +3125 2192(c)N +2144(c)Y +2056(c)Y +1968(c)Y +1880(c)Y +1792(c)Y +1704(c)Y +1616(c)Y +1528(c)Y +1440(c)Y +1352(c)Y +1264(c)Y +1176(c)Y +1088(c)Y +1000(c)Y +3481 2192(c)N +2152(c)Y +2064(c)Y +1976(c)Y +1888(c)Y +1800(c)Y +1712(c)Y +1624(c)Y +1536(c)Y +1448(c)Y +1360(c)Y +1272(c)Y +1184(c)Y +1096(c)Y +1008(c)Y +920(c)Y +832(c)Y +744(c)Y +1 f +1463 2464(Table)N +1686(5:)X +1777(Times)X +2020(\(in)X +2140(seconds\))X +2469(for)X +2593(matrix)X +2846 0.3365(multiplication)AX +576 2688(\(such)N +790(as)X +887(\256lesystems)X +1303(etc.\))X +1481(may)X +1657(be)X +1764(exploited;)X +2142(for)X +2268(very)X +2449(large)X +2650(datasets,)X +2976(asymmetric)X +3413(partitioning)X +3851(algo-)X +576 2800(rithms)N +824(can)X +968(contribute)X +1348(signi\256cantly)X +1807(to)X +1898(reduced)X +2198(I/O)X +2337(and)X +2486(swapping)X +2845(overheads.)X +3 f +576 3136(5.2.)N +752(Contaminant)X +1272(Transport)X +1680(Simulation)X +1 f +776 3388(To)N +896(further)X +1157(exercise)X +1468(the)X +1599(heterogeneous)X +2130(computing)X +2531(facilities)X +2859(in)X +3 f +9 s +2947(PVM)X +1 f +11 s +3111(,)X +3156(an)X +3262(interactive)X +3658(simulation)X +576 3500(program)N +900(was)X +1062(ported)X +1313(to)X +1408(the)X +1541(system.)X +1833(This)X +2015(simulation)X +2414(models)X +2694(contaminant)X +3156(transport)X +3494(in)X +3588(groundwater)X +576 3612(\257ow,)N +777(and)X +927(is)X +1010(part)X +1171(of)X +1268(a)X +1331(larger)X +1560(and)X +1711(more)X +1916(comprehensive)X +2473(simulation)X +2871(effort.)X +3112(Preliminary)X +3553(\256ndings)X +3861(from)X +576 3724(this)N +727(work)X +930(are)X +1060(reported)X +1376(in)X +1468([2].)X +1615(The)X +1774(major)X +2002(components)X +2450(of)X +2545(the)X +2675(existing)X +2977(software)X +3301(are)X +3430(a)X +3491(graphical)X +3841(inter-)X +576 3836(face)N +754(and)X +913(the)X +1053(solution)X +1370(of)X +1476(sets)X +1641(of)X +1747(differential)X +2172(equations)X +2543(involving)X +2915(transport)X +3261(calculations)X +3716(and)X +3876(\257ow)X +576 3948(calculations.)N +1043(The)X +1203(transport)X +1539(calculations)X +1984(are)X +2114(highly)X +2363(parallelizable,)X +2884(while)X +3103(the)X +3234(\257ow)X +3413(equations)X +3774(may)X +3949(be)X +576 4060(well)N +786(solved)X +1074(on)X +1220(a)X +1317(fast)X +1502(scalar)X +1765(machine.)X +2144(The)X +2340(existing)X +2679 0.2885(implementation)AX +3294(encountered)X +3783(several)X +576 4172(dif\256culties,)N +1003(including)X +1364(the)X +1499(interfacing)X +1908(of)X +2007(the)X +2141(two)X +2299(computational)X +2831(components,)X +3305(the)X +3439(transfer)X +3733(of)X +3832(struc-)X +576 4284(tured)N +786(data)X +962(between)X +1284(multiple)X +1631(instances,)X +2006(and)X +2163(interactions)X +2605(with)X +2792(an)X +2905(X-windows)X +3344(graphical)X +3702(interface.)X +576 4396(The)N +735(latter)X +939(issue)X +1137(was)X +1295(particularly)X +1724(cumbersome)X +2196(when)X +2408(the)X +2538(system)X +2805(was)X +2963(run)X +3102(over)X +3280(a)X +3341(wide)X +3534(area)X +3702(network.)X +776 4648(The)N +947(simulation)X +1355(programs)X +1721(were)X +1925(ported)X +2184(for)X +3 f +9 s +2316(PVM)X +1 f +11 s +2515(use,)X +2689(by)X +2812(partitioning)X +3260(the)X +3403(system)X +3683(into)X +3856(three)X +576 4760(components)N +1030(-)X +1087(the)X +1223(transport)X +1564(calculations)X +2014(\(executed)X +2384(on)X +2500(a)X +2567(hypercube\),)X +3012(the)X +3147(\257ow)X +3330(equations)X +3695(\(on)X +3839(a)X +3905(fast)X +576 4872(scalar)N +807(machine\),)X +1183(and)X +1336(the)X +1470(graphical)X +1824(interface)X +2158(on)X +2272(a)X +2337(Sun)X +2500(workstation.)X +2964(Very)X +3165(few)X +3322(modi\256cations)X +3829(in)X +3924(the)X +576 4984(existing)N +900(codes)X +1144(were)X +1358(required;)X +1719(the)X +1870(scalar)X +2118(and)X +2288(hypercube)X +2697(components)X +3166(interacted)X +3557(via)X +3708(emulated)X +576 5096(shared)N +828(memory)X +1145(while)X +1364(the)X +1495(graphics)X +1816(component)X +2231(used)X +2415(the)X +2546(fast)X +2696(message)X +3017(passing)X +3304(primitives)X +3686(in)X +3 f +9 s +3775(PVM)X +1 f +11 s +3963(to)X +576 5208(achieve)N +868(better)X +1092(response)X +1422(and)X +1571(lowered)X +1876(latency.)X +2175(An)X +2304(additional)X +2680(bene\256t)X +2942(was)X +3100(the)X +3230(mobility)X +3553(of)X +3648(the)X +3778(graphi-)X +576 5320(cal)N +705(interface)X +1039(component;)X +1482(due)X +1635(to)X +1731(the)X +1866(connectionless)X +2412(nature)X +2659(of)X +3 f +9 s +2755(PVM)X +1 f +11 s +2946(interactions,)X +3407(it)X +3484(was)X +3647(possible)X +3963(to)X +576 5432(execute)N +877(the)X +1017(graphical)X +1377(interface)X +1717(program)X +2047(from)X +2250(different)X +2585(locations)X +2936(in)X +3037(a)X +3107(manner)X +3402(transparent)X +3824(to)X +3924(the)X +576 5544(computational)N +1108(components.)X +1582(Further,)X +1889(multiple)X +2211(displays)X +2527(were)X +2724(possible)X +3040(by)X +3155(using)X +3373(the)X +3 f +9 s +3504(PVM)X +1 f +11 s +3695(broadcast)X +576 5656(facilities,)N +930(a)X +996(useful)X +1238(feature)X +1509(when)X +1725(several)X +2000(simultaneous)X +2492(users)X +2698(wish)X +2890(to)X +2985(interact)X +3276(with)X +3459(the)X +3593(system.)X +3886(Due)X +576 5768(to)N +668(the)X +799(interactive)X +1195(nature)X +1438(of)X +1534(the)X +1665(application,)X +2103(performance)X +2570(timings)X +2859(are)X +2989(not)X +3125(meaningful;)X +3576(however,)X +3924(the)X + +23 p +%%Page: 23 23 +11 s 11 xH 0 xS 1 f +2209 400(-)N +2260(23)X +2370(-)X +576 688(system)N +843(performed)X +1231(without)X +1523(any)X +1672(noticeable)X +2057(degradation)X +2495(when)X +2707(executed)X +3042(under)X +3 f +9 s +3260(PVM)X +1 f +11 s +3424(.)X +3 f +576 1024(6.)N +686(Conclusions)X +1163(and)X +1327(Future)X +1608(Work)X +1 f +776 1276(The)N +947(primary)X +1260(motivation)X +1678(for)X +1814(the)X +3 f +9 s +1952(PVM)X +1 f +11 s +2150(project)X +2429(is)X +2522(derived)X +2820(from)X +3025(the)X +3167(existing)X +3482(and)X +3644(anticipated)X +576 1388(need)N +770(for)X +900(a)X +967(general,)X +1276(\257exible,)X +1591(and)X +1746(inexpensive)X +2195(concurrent)X +2599(programming)X +3107(environment.)X +3602(Experiences)X +576 1500(with)N +763(the)X +901(system)X +1177(have)X +1374(demonstrated)X +1880(that)X +2044(such)X +2236(a)X +2306(framework)X +2722(can)X +2875(be)X +2989(provided)X +3333(and)X +3491(can)X +3644(execute)X +3944(on)X +576 1612(existing)N +881(hardware)X +1232(bases,)X +1469(with)X +1651(the)X +1784(bene\256ts)X +2083(of)X +2181(a)X +2245(procedural)X +2646(programming)X +3151(interface)X +3484(and)X +3636(straightfor-)X +576 1724(ward)N +777(constructs)X +1160(for)X +1288(access)X +1538(to)X +1633(various)X +1918(resources.)X +2297(A)X +2386(noteworthy)X +2813(feature)X +3083(of)X +3 f +9 s +3178(PVM)X +1 f +11 s +3368(is)X +3453(its)X +3564(generality)X +3944(\320)X +576 1836(supporting)N +984(both)X +1172(the)X +1310(shared-memory)X +1892(and)X +2049(message-passing)X +2670(paradigms)X +3067(on)X +3185(a)X +3254(heterogeneous)X +3792(collec-)X +576 1948(tion)N +736(of)X +831(machines)X +1186(is)X +1267(useful.)X +1548(The)X +1707(framework)X +2114(provided)X +2450(by)X +3 f +9 s +2557(PVM)X +1 f +11 s +2744(enables)X +3031(interaction)X +3432(between)X +3748(applica-)X +576 2060(tion)N +754(components)X +1220(and)X +1387(machine)X +1726(architectures)X +2216(that)X +2389(are)X +2536(normally)X +2895(incompatible.)X +3418(Anticipating)X +3899(that)X +576 2172(large)N +776(and)X +927(complex)X +1255(parallel)X +1544(systems)X +1847(will)X +2009(require)X +2282(error)X +2476(indication)X +2854(and)X +3005(failure)X +3259(detection)X +3607(capabilities,)X +576 2284(such)N +762(features)X +1065(have)X +1256(been)X +1447(built)X +1635(into)X +1798(the)X +3 f +9 s +1927(PVM)X +1 f +11 s +2116(system)X +2386(and)X +2538(are)X +2670(likely)X +2897(to)X +2990(be)X +3097(valuable.)X +3442(From)X +3657(the)X +3789(perfor-)X +576 2396(mance)N +837(point)X +1050(of)X +1154(view,)X +3 f +9 s +1374(PVM)X +1 f +11 s +1569(has)X +1717(proven)X +1992(to)X +2092(be)X +2207(acceptable)X +2611(even)X +2809(for)X +2943(applications)X +3402(with)X +3591(a)X +3662(high)X +3851(com-)X +576 2508(munication)N +1009(to)X +1113(computation)X +1590(ratio)X +1787(\320)X +1910(although)X +2253(its)X +2371(primary)X +2684(intent)X +2920(is)X +3013(to)X +3116(support)X +3414(applications)X +3875(with)X +576 2620(much)N +795(larger)X +1023(grainsize)X +1365(and)X +1516(less)X +1672(interaction.)X +2096(Perhaps)X +2398(of)X +2495(more)X +2700(importance)X +3121(in)X +3214(certain)X +3478(situations)X +3841(is)X +3924(the)X +576 2732(ability)N +829(of)X +3 f +9 s +924(PVM)X +1 f +11 s +1114(to)X +1209(utilize)X +1457(resources)X +1814(that)X +1973(already)X +2258(exist)X +2451(and)X +2604(would)X +2850(be)X +2959(wasted)X +3229(otherwise,)X +3619(not)X +3757(to)X +3851(men-)X +576 2844(tion)N +740(its)X +850(value)X +1067(as)X +1166(a)X +1231(prototyping)X +1669(tool)X +1833(for)X +1961(new)X +2133(algorithms)X +2537(or)X +2636(applications.)X +3133(The)X +3296 0.3403(simplicity)AX +3677(of)X +3777(porting)X +576 2956(the)N +3 f +9 s +705(PVM)X +1 f +11 s +894(system)X +1164(as)X +1262(well)X +1439(as)X +1537(application)X +1955(software)X +2282(also)X +2449(enhances)X +2796(its)X +2905(appeal)X +3160(and)X +3311(will)X +3473(contribute)X +3855(to)X +3948(its)X +576 3068(increased)N +930(use.)X +776 3320(There)N +1003(are,)X +1154(however,)X +1500(several)X +1771(aspects)X +2047(to)X +3 f +9 s +2134(PVM)X +1 f +11 s +2320(that)X +2475(require)X +2746(further)X +3008(work;)X +3236(some)X +3445(efforts)X +3697(are)X +3827(ongo-)X +576 3432(ing)N +720(while)X +947(others)X +1193(are)X +1331(planned)X +1641(for)X +1774(the)X +1913(future.)X +2198(A)X +2292(very)X +2479(valuable)X +2809(addition)X +3129(would)X +3379(be)X +3492(a)X +3561(supplemental)X +576 3544(toolkit)N +832(that)X +989(assisted)X +1287(in)X +1380(algorithm)X +1748(partitioning)X +2185(and)X +2336(scheduling,)X +2764(as)X +2861(well)X +3037(as)X +3134(support)X +3423(for)X +3550(the)X +3683(automatic)X +576 3656(compilation)N +1024(of)X +1122(different)X +1450(object)X +1691(modules)X +2015(for)X +2142(different)X +2470(architectures.)X +2967(From)X +3183(the)X +3316(system)X +3585(implementa-)X +576 3768(tion)N +742(point)X +952(of)X +1053(view,)X +1274(it)X +1352(is)X +1439(evident)X +1727(that)X +1888(the)X +2024(data)X +2199(transfer,)X +2518(broadcast,)X +2906(and)X +3062(mutual)X +3337(exclusion)X +3704(protocols)X +576 3880(are)N +712(the)X +849(most)X +1050(crucial)X +1319(primitives,)X +1729(and)X +1885(work)X +2094(is)X +2181(in)X +2278(progress)X +2603(to)X +2700(optimize)X +3038(these.)X +3269(Con\257ict)X +3582(resolution)X +3963(in)X +576 3992(the)N +716(locking)X +1013(algorithm)X +1389(presently)X +1744(uses)X +1927(a)X +1999(heuristic)X +2336(method)X +2634(\320)X +2755(a)X +2827(provably)X +3173(correct)X +3450(formalization)X +3959(of)X +576 4104(this)N +727(will)X +887(be)X +992(undertaken)X +1405(soon.)X +1615(From)X +1828(the)X +1958(application)X +2373(point)X +2577(of)X +2672(view,)X +2887(certain)X +3149(additional)X +3525(features)X +3825(might)X +576 4216(be)N +695(desirable)X +1050(such)X +1248(as)X +1358(\(1\))X +1497(the)X +1642(ability)X +1906(to)X +2012(coalesce)X +2347(emulated)X +2708(and)X +2872(real)X +3041(shared)X +3307(memory,)X +3660(and)X +3824(\(2\))X +3963(to)X +576 4328(dynamically)N +1046(optimize)X +1389(message)X +1720(passing,)X +2039(locking)X +2337(etc.,)X +2517(depending)X +2917(on)X +3038(the)X +3178(architecture)X +3626(on)X +3746(which)X +3993(a)X +576 4440(component)N +1003(instance)X +1327(is)X +1421(executing.)X +1821(Also)X +2022(planned)X +2336(for)X +2473(the)X +2616(future)X +2861(are)X +3003(a)X +3078(graphical)X +3442(interface)X +3786(for)X +3924(the)X +576 4552(speci\256cation)N +1049(of)X +1149(component)X +1568(execution)X +1938(order)X +2149(and)X +2302(interactions,)X +2762(as)X +2861(well)X +3039(as)X +3138(debugging)X +3536(and)X +3689(execution)X +576 4664(history)N +843(trace)X +1036(facilities.)X +3 f +576 5000(Acknowledgments)N +1 f +776 5252(The)N +935(author)X +1182(is)X +1263(indebted)X +1589(to)X +1680(the)X +1810(referees,)X +2131(particularly)X +2560(the)X +2690(second)X +2956(referee,)X +3243(for)X +3367(detailed)X +3669(comments)X +576 5364(that)N +739(resulted)X +1048(in)X +1147(many)X +1373(improvements)X +1908(in)X +2007(the)X +2145(system)X +2419(and)X +2575(this)X +2732(paper.)X +2978(Thanks)X +3266(are)X +3402(also)X +3573(due)X +3729(to)X +3827(M.)X +3956(T.)X +576 5476(Heath,)N +831(G.)X +939(A.)X +1047(Geist,)X +1278(T.)X +1377(H.)X +1485(Dunigan,)X +1833(and)X +1983(D.)X +2092(A.)X +2201(Poplawski)X +2592(for)X +2718(helpful)X +2992(discussions)X +3417(during)X +3671(the)X +3803(course)X +576 5588(of)N +671(this)X +821(work)X +1023(and)X +1172(for)X +1296(their)X +1480(comments)X +1865(on)X +1975(earlier)X +2222(versions)X +2537(of)X +2632(this)X +2782(paper.)X + +24 p +%%Page: 24 24 +11 s 11 xH 0 xS 1 f +2209 400(-)N +2260(24)X +2370(-)X +3 f +576 688(References)N +1 f +576 940([1])N +776(K.)X +896(Hwang,)X +1206(F.)X +1312(A.)X +1432(Briggs,)X +2 f +1724(Computer)X +2112(Architecture)X +2589(and)X +2757(Parallel)X +3083(Processing)X +1 f +3474(,)X +3532(McGraw-Hill,)X +776 1052(New)N +963(York,)X +1187(1984.)X +576 1192([2])N +776(H.)X +884(Narang,)X +1188(R.)X +1293(Flanery,)X +1608(J.)X +1688(Drake,)X +2 f +1948(Design)X +2221(of)X +2314(a)X +2382(Simulation)X +2789(Interface)X +3131(for)X +3258(a)X +3326(Parallel)X +3640(Computing)X +776 1304(Environment)N +1 f +1231(,)X +1275(Proc.)X +1502(ACM)X +1724(Southeastern)X +2201(Regional)X +2542(Conference,)X +2991(April)X +3199(1990,)X +3419(to)X +3510(appear.)X +576 1444([3])N +776(G.)X +888(A.)X +1000(Geist,)X +1235(M.)X +1362(T.)X +1465(Heath,)X +1724(B.)X +1832(W.)X +1964(Peyton,)X +2258(P.)X +2356(H.)X +2468(Worley,)X +2 f +2781(A)X +2862(Machine)X +3198(Independent)X +3661(Communi-)X +776 1556(cation)N +1023(Library)X +1 f +1292(,)X +1339(Proc.)X +1547(Hypercube)X +1957(Concurrent)X +2378(Computers)X +2790(Conference)X +3220(1989,)X +3443(J.)X +3524(Gustafson)X +3905(ed.,)X +776 1668(to)N +867(appear.)X +576 1808([4])N +776(T.)X +881(J.)X +966(Gardner,)X +2 f +1304(et.)X +1419(al.)X +1 f +1510(,)X +2 f +1561(DPUP)X +1824(:)X +1882(A)X +1965(Distributed)X +2418(Processing)X +2838(Utilities)X +3153(Package)X +1 f +3456(,)X +3507(Computer)X +3890(Sci-)X +776 1920(ence)N +959(Technical)X +1329(Report,)X +1613(University)X +2007(of)X +2102(Colorado,)X +2474(Boulder,)X +2802(1986.)X +576 2060([5])N +776(T.)X +895(H.)X +1023(Dunigan,)X +2 f +1391(Hypercube)X +1819(Simulation)X +2245(on)X +2376(a)X +2463(Local)X +2707(Area)X +2921(Network)X +1 f +3220(,)X +3285(Oak)X +3474(Ridge)X +3728(National)X +776 2172(Laboratory)N +1189(Report)X +1451(ORNL/TM-10685,)X +2140(November)X +2533(1988.)X +576 2312([6])N +776(C.)X +884(Seitz,)X +1110(J.)X +1193(Seizovic,)X +1546(W.)X +1678(K.)X +1790(Su,)X +2 f +1932(The)X +2091(C)X +2177(programmer's)X +2710(Abbreviated)X +3168(Guide)X +3411(to)X +3508(Multicomputer)X +776 2424(Programming)N +1 f +1269(,)X +1313(Caltech)X +1605(Computer)X +1980(Science)X +2276(Report,)X +2560(CS-TR-88-1,)X +3044(January)X +3339(1988.)X +576 2564([7])N +776(M.)X +914(Sullivan,)X +1269(D.)X +1392(Anderson,)X +2 f +1793(Marionette:)X +2252(A)X +2344(System)X +2627(for)X +2769(Parallel)X +3098(Distributed)X +3539(Programming)X +776 2676(Using)N +1008(a)X +1074(Master/Slave)X +1561(Model)X +1 f +1786(,)X +1830(Proc.)X +2057(9th)X +2192(ICDCS,)X +2495(June)X +2678(1989,)X +2898(pp.)X +3030(181-188.)X +576 2816([8])N +776(G.)X +906(Riccardi,)X +1272(B.)X +1398(Traversat,)X +1797(U.)X +1927(Chandra,)X +2 f +2293(A)X +2393(Master-Slaves)X +2942(Parallel)X +3278(Computation)X +3785(Model)X +1 f +4010(,)X +776 2928(Supercomputer)N +1336(Research)X +1680(Institute)X +1992(Report,)X +2276(Florida)X +2553(State)X +2752(University,)X +3168(June)X +3351(1989.)X +576 3068([9])N +776(Intel)X +960(iPSC/2)X +1233(Programmer's)X +1758(Reference)X +2136(Manual,)X +2449(Intel)X +2633(Corporation,)X +3103(Beaverton,)X +3509(March)X +3760(1988.)X +576 3208([10])N +776(A.)X +883(Karp,)X +2 f +1102(Programming)X +1617(for)X +1742(Parallelism)X +1 f +2154(,)X +2198(IEEE)X +2411(Computer,)X +2808(May)X +2991(1987,)X +3211(pp.)X +3343(43-57.)X +576 3348([11])N +776(J.)X +865(B.)X +979(Postel,)X +2 f +1251(User)X +1455(Datagram)X +1850(Protocol)X +1 f +2159(,)X +2215(Internet)X +2523(Request)X +2841(for)X +2977(Comments)X +3394(RFC-768,)X +3778(August)X +776 3460(1980.)N +576 3600([12])N +776(N.)X +888(Maekawa,)X +2 f +1279(A)X +9 f +1361 3583 MXY +(sr)214 549 oc +10 f +1409(d)X +1423(d)X +2 f +1409 3600(n)N +1495(Algorithm)X +1881(for)X +2012(Mutual)X +2295(Exclusion)X +2671(in)X +2768(Decentralized)X +3290(Systems,)X +3618(ACM)X +3832(Tran-)X +776 3712(sactions)N +1087(on)X +1197(Computer)X +1571(Systems,)X +1893(May)X +2071(1985,)X +2291(pp.)X +2423(145-159.)X +1 f +576 3852([13])N +776(K.)X +895(Raymond,)X +2 f +1294(A)X +1382(Tree)X +1577(Based)X +1827(Algorithm)X +2220(for)X +2358(Distributed)X +2795(Mutual)X +3085(Exclusion)X +1 f +3433(,)X +3490(ACM)X +3725(Transac-)X +776 3964(tions)N +970(on)X +1080(Computer)X +1455(Systems,)X +1793(February)X +2132(1989,)X +2352(pp.)X +2484(61-77.)X +576 4104([14])N +776(D.)X +886(Agarwal,)X +1235(A.)X +1345(E.)X +1446(Abbadi,)X +2 f +1752(An)X +1875(Ef\256cient)X +2195(Solution)X +2515(to)X +2610(the)X +2744(Distributed)X +3172(Mutual)X +3453(Exclusion)X +3827(Prob-)X +776 4216(lem)N +1 f +903(,)X +947(Proc.)X +1152(Principles)X +1527(of)X +1622(Distributed)X +2041(Computing)X +2461(Conference,)X +2910(Edmonton,)X +3322(August)X +3598(1989.)X +576 4356([15])N +776(J.)X +856(S.)X +951(Chase)X +2 f +1190(et.)X +1300(al.)X +1 f +1391(,)X +2 f +1437(The)X +1593(Amber)X +1851(System:)X +2148(Parallel)X +2462(Programming)X +2979(on)X +3091(a)X +3159(Network)X +3483(of)X +3577(Multiproces-)X +776 4468(sors)N +1 f +922(,)X +966(to)X +1057(appear)X +1313(in)X +1404(12th)X +1583(SOSP,)X +1837(Litch\256eld)X +2203(Park,)X +2408(November)X +2801(1989.)X +576 4608([16])N +776(G.)X +891(A.)X +1006(Geist,)X +1244(M.)X +1374(T.)X +1480(Heath,)X +2 f +1742(Matrix)X +2012(Factorization)X +2524(on)X +2643(Hypercube)X +3059(Multiprocessors)X +1 f +(,)S +3684(in)X +3784(Hyper-)X +776 4720(cube)N +964(Multiprocessors)X +1553(1986,)X +1773(SIAM,)X +2036(Philadelphia,)X +2522(1986,)X +2742(pp.)X +2874(161-180.)X +576 4860([17])N +776(D.)X +891(W.)X +1026(Lozier,)X +1308(R.)X +1419(G.)X +1535(Rehm,)X +2 f +1799(Some)X +2020(Performance)X +2510(Comparisons)X +3010(for)X +3144(a)X +3219(Fluid)X +3442(Dynamics)X +3824(Code)X +1 f +4010(,)X +776 4972(Parallel)N +1068(Computing,)X +1510(Vol.)X +1686(11,)X +1818(pp.)X +1950(305-320,)X +2287(1989.)X +576 5112([18])N +776(G.)X +884(C.)X +988(Fox,)X +1170(S.)X +1264(W.)X +1392(Otto,)X +2 f +1594(Matrix)X +1858(Algorithms)X +2274(on)X +2386(a)X +2454(Hypercube)X +2863(I:)X +2945(Matrix)X +3209 0.2740(Multiplication)AX +1 f +3716(,)X +3762(Parallel)X +776 5224(Computing,)N +1218(Vol.)X +1394(4,)X +1482(pp.)X +1614(17-31,)X +1863(1987.)X +576 5364([19])N +776(A.)X +902(Osterhaug,)X +2 f +1326(Guide)X +1583(to)X +1694(Parallel)X +2026(Programming)X +2561(on)X +2691(Sequent)X +3012(Computer)X +3406(Systems)X +1 f +3684(,)X +3748(Sequent)X +776 5476(Computer)N +1151(Systems,)X +1489(Inc.,)X +1667(Beaverton,)X +2073(1986.)X +576 5616([20])N +776(R.)X +886(Finkel,)X +1163(E.)X +1268(Styer,)X +1505(U.)X +1619(Manber,)X +2 f +1943(Designing)X +2334(Ef\256cient)X +2658(Barriers)X +2985(in)X +3084(Communication)X +3677(Networks)X +1 f +4010(,)X +776 5728(University)N +1170(of)X +1265(Kentucky)X +1629(Technical)X +1999(Report,)X +2283(No.)X +2434(165-90,)X +2727(March)X +2978(1990.)X + +25 p +%%Page: 25 25 +11 s 11 xH 0 xS 1 f +2209 400(-)N +2260(25)X +2370(-)X +3 f +1459 688(Appendix)N +1848(\320)X +1958(PVM)X +2180(User)X +2377(Interface)X +2740(Constructs)X +576 940(enroll)N +1 f +797(\()X +2 f +826(<name>)X +1 f +1134(\))X +776 1080(Enroll)N +1019(calling)X +1282(process)X +1567(as)X +2 f +1662(<name>)X +1 f +1970(.)X +2014(Returns)X +2310(instance)X +2621(number.)X +3 f +576 1248(initiate)N +1 f +841(\()X +2 f +870(<component)X +1337(name>)X +1 f +1586(\))X +776 1388(Start)N +965(new)X +1133(process)X +1418(speci\256ed)X +1753(by)X +2 f +1863(<component)X +2330(name>)X +1 f +2579(.)X +2623(Returns)X +2919(instance)X +3230(number.)X +3 f +576 1556(initiateP)N +1 f +895(\()X +2 f +924(<name1>)X +1 f +1276(,)X +2 f +(<name2>)S +1 f +1650(,)X +2 f +(<inum>)S +1 f +1966(\))X +776 1696(Start)N +965(new)X +1133(instance)X +1444(of)X +2 f +1539(<name1>)X +1 f +1913(when)X +2 f +2125(<name2>)X +1 f +2477(/)X +2 f +2502(<inum>)X +1 f +2818(terminates.)X +3 f +576 1864(initiateD)N +1 f +904(\()X +2 f +933(<name>)X +1 f +1241(,)X +2 f +(<event>)S +1 f +1567(\))X +776 2004(Start)N +965(new)X +1133(instance)X +1444(of)X +2 f +1539(<name>)X +1 f +1869(when)X +2 f +2081(<event>)X +1 f +2407(occurs.)X +3 f +576 2172(ready)N +1 f +791(\()X +2 f +820(<event>)X +1 f +1124(\))X +776 2312(Inform)N +3 f +9 s +1038(PVM)X +1 f +11 s +1224(system)X +1491(of)X +1586(occurrence)X +1993(of)X +2 f +2088(<event>)X +1 f +2392(.)X +3 f +576 2480(terminate)N +1 f +942(\()X +2 f +971(<name>)X +1 f +1279(,)X +2 f +(<inum>)S +1 f +1595(\))X +776 2620(Terminate)N +1161(instance)X +2 f +1472(<inum>)X +1 f +1788(of)X +1883(component)X +2 f +2297(<name>)X +1 f +2605(.)X +3 f +576 2788(waitprocess)N +1 f +1015(\()X +2 f +1044(<name>)X +1 f +1352(,)X +2 f +(<inum>)S +1 f +1668(\))X +776 2928(Block)N +1009(caller)X +1227(until)X +1412(instance)X +2 f +1723(<inum>)X +1 f +2039(of)X +2 f +2134(<name>)X +1 f +2464(terminates.)X +3 f +576 3096(send)N +1 f +747(\()X +2 f +776(<name>)X +1 f +1084(,)X +2 f +(<inum>)S +1 f +1400(,)X +2 f +(<type>)S +1 f +1687(\))X +776 3236(Send)N +983(message)X +1312(of)X +1417(speci\256ed)X +1762(type)X +1946(to)X +2047(speci\256ed)X +2392(destination)X +2812(process.)X +3129(Negative)X +3479(return)X +3721(value)X +3944(on)X +776 3348(failure.)N +3 f +576 3516(recv)N +1 f +737(\()X +2 f +766(<type>)X +1 f +1031(\))X +776 3656(Receive)N +1082(message)X +1402(of)X +1497(speci\256ed)X +1832(type.)X +3 f +576 3824(recv1)N +1 f +781(\()X +2 f +810(<type>)X +1 f +1075(,)X +2 f +(<other_limit>)S +1 f +1608(\))X +776 3964(Receive)N +1092(message)X +1422(of)X +1527(speci\256ed)X +1873(type;)X +2 f +2083(<other_limit>)X +1 f +2627(msgs)X +2841(of)X +2947(other)X +3161(types)X +3380(allowed.)X +3714(Negative)X +776 4076(return)N +1008(value)X +1221(on)X +1331(failure.)X +3 f +576 4244(recv2)N +1 f +781(\()X +2 f +810(<type1>)X +1 f +1119(,)X +2 f +(<timeout>)S +1 f +1524(\))X +776 4384(Receive)N +1118(message)X +1452(of)X +1561(speci\256ed)X +1910(type)X +2098(within)X +2 f +2360(<timeout>)X +1 f +2779(seconds.)X +3115(Negative)X +3469(return)X +3716(value)X +3944(on)X +776 4496(failure.)N +3 f +576 4664(putstring)N +1 f +923(\()X +2 f +952(<string>)X +1 f +1276(\))X +776 4804(Store)N +2 f +984(<string>)X +1 f +1330(in)X +1421(send)X +1604(buffer)X +1840(in)X +1931(machine)X +2252(independent)X +2705(form.)X +3 f +576 4972(putint)N +1 f +806(\()X +2 f +835(<num>)X +1 f +1104(\))X +776 5112(Store)N +984(integer)X +1251(in)X +1342(send)X +1525(buffer)X +1761(in)X +1852(machine)X +2173(independent)X +2626(form.)X +3 f +576 5280(put\257oat)N +1 f +869(\()X +2 f +898(<fnum>)X +1 f +1192(\))X +776 5420(Store)N +984(real)X +1138(number)X +1429(in)X +1520(send)X +1703(buffer)X +1939(in)X +2030(machine)X +2351(independent)X +2804(form.)X +3 f +576 5588(getstring)N +1 f +908(\()X +2 f +937(<string_ptr>)X +1 f +1408(\))X +776 5728(Retrieve)N +1097(string)X +1320(from)X +1513(receive)X +1789(buffer)X +2025(in)X +2116(machine)X +2437(dependent)X +2821(form.)X + +26 p +%%Page: 26 26 +11 s 11 xH 0 xS 1 f +2209 400(-)N +2260(26)X +2370(-)X +3 f +576 688(getint)N +1 f +791(\()X +2 f +820(<integer_ptr>)X +1 f +1335(\))X +776 828(Retrieve)N +1097(integer)X +1364(from)X +1557(receive)X +1833(buffer)X +2069(in)X +2160(machine)X +2481(dependent)X +2865(form.)X +3 f +576 996(get\257oat)N +1 f +854(\()X +2 f +883(<\257oat_ptr>)X +1 f +1305(\))X +776 1136(Retrieve)N +1097(real)X +1251(number)X +1542(from)X +1735(receive)X +2011(buffer)X +2247(in)X +2338(machine)X +2659(dependent)X +3043(form.)X +3 f +576 1304(recvinfo)N +1 f +884(\()X +2 f +913(<string_ptr>)X +1 f +1384(,)X +2 f +(<inum_ptr>)S +1 f +1847(,)X +2 f +(<len_ptr>)S +1 f +2242(\))X +776 1444(Return)N +1038(source)X +1289(name,)X +1524(instance)X +1835(number,)X +2148(and)X +2297(length)X +2540(of)X +2635(last)X +2780(received)X +3100(message.)X +3 f +576 1612(broadcast)N +1 f +947(\()X +2 f +976(<name>)X +1 f +1284(\))X +776 1752(Broadcast)N +1150(send)X +1333(buffer)X +1569(to)X +1660(all)X +1771(instances)X +2116(of)X +2 f +2211(<name>)X +1 f +2519(.)X +2563(Returns)X +2859(actual)X +3092(number)X +3383(of)X +3478(recipients.)X +3 f +576 1920(barrier)N +1 f +850(\()X +2 f +879(<number>)X +1 f +1265(\))X +776 2060(Blocks)N +1049(caller)X +1274(until)X +1466(speci\256ed)X +1808(number)X +2106(of)X +2208(instances)X +2560(arrive)X +2794(at)X +2887(barrier.)X +3172(Negative)X +3519(return)X +3758(value)X +3978(if)X +776 2172(some)N +984(instances)X +1329(have)X +1517(terminated.)X +3 f +576 2340(waituntil)N +1 f +914(\()X +2 f +943(<event>)X +1 f +1247(\))X +776 2480(Blocks)N +1043(caller)X +1261(until)X +1446(speci\256ed)X +1781(event)X +1994(occurs.)X +3 f +576 2648(shmget)N +1 f +844(\()X +2 f +873(<key>)X +1 f +1108(,)X +2 f +(<size>)S +1 f +1380(\))X +776 2788(Allocates)N +1134(shared)X +1388(memory)X +1708(segment)X +2028(of)X +2127(speci\256ed)X +2466(size)X +2629(identi\256ed)X +2989(by)X +2 f +3103(<key>)X +1 f +3338(.)X +3408(A)X +3497(negative)X +3822(return)X +776 2900(value)N +989(indicates)X +1325(that)X +1480(the)X +1610(key)X +1759(value)X +1972(is)X +2053(already)X +2334(in)X +2425(use.)X +3 f +576 3068(shmat)N +1 f +805(\()X +2 f +834(<key>)X +1 f +1069(,)X +2 f +(<ptr>)S +1 f +1312(,)X +2 f +(<\257ag>)S +1 f +1584(,)X +2 f +(<timeout>)S +1 f +1989(\))X +776 3208(Locks)N +1022(shared)X +1282(memory)X +1607(segment)X +1932(identi\256ed)X +2297(by)X +2 f +2416(<key>)X +1 f +2682(and)X +2840(maps)X +3057(segment)X +3382(at)X +3478(caller's)X +3769(address)X +776 3320(space)N +998(starting)X +1289(at)X +2 f +1379(ptr>)X +1 f +1541(.)X +1589("R")X +1746(or)X +1845("RW")X +2085(are)X +2218(possible)X +2533(\257ag)X +2691(values;)X +2967(a)X +3032(negative)X +3357(value)X +3574(is)X +3659(returned)X +3978(if)X +776 3432(the)N +910(attach)X +1147(does)X +1334(not)X +1473(succeed)X +1778(within)X +2 f +2031(<timeout>)X +1 f +2441(seconds.)X +2768(A)X +2858(0)X +2929(timeout)X +3227(value)X +3445(causes)X +3701(the)X +3836(caller)X +776 3544(to)N +867(block)X +1085(until)X +1270(successful.)X +3 f +576 3712(shmatint)N +1 f +908(\()X +2 f +937(<key>)X +1 f +1172(,)X +2 f +(<integer_ptr>)S +1 f +1709(,)X +2 f +(<\257ag>)S +1 f +1981(,)X +2 f +(<timeout>)S +1 f +2386(\))X +776 3852(Variant)N +1062(of)X +3 f +1157(shmat)X +1 f +1408(that)X +1563(maps)X +1771(segment)X +2087(in)X +2178(typed)X +2396(form)X +2589(as)X +2684(integer)X +2951(array.)X +3 f +576 4020(shmat\257oat)N +1 f +971(\()X +2 f +1000(<key>)X +1 f +1235(,)X +2 f +(<\257oat_ptr>)S +1 f +1679(,)X +2 f +(<\257ag>)S +1 f +1951(,)X +2 f +(<timeout>)S +1 f +2356(\))X +776 4160(Variant)N +1062(of)X +3 f +1157(shmat)X +1 f +1408(that)X +1563(maps)X +1771(segment)X +2087(in)X +2178(typed)X +2396(form)X +2589(as)X +2684(\257oat)X +2863(array.)X +3 f +576 4328(shmdt)N +1 f +810(\()X +2 f +839(<key>)X +1 f +1074(,)X +2 f +(<ptr>)S +1 f +1317(\))X +776 4468(Unlocks)N +1100(and)X +1258(unmaps)X +1563(speci\256ed)X +1907(shared)X +2167(memory)X +2492(segment)X +2817(from)X +3019(process')X +3343(address)X +3638(space)X +3865(indi-)X +776 4580(cated)N +984(by)X +2 f +1094(<ptr>)X +1 f +1315(.)X +3 f +576 4748(shmdtint)N +1 f +913(\()X +2 f +942(<key>)X +1 f +1177(,)X +2 f +(<integer_ptr>)S +1 f +1714(\))X +776 4888(Unlocks)N +1110(and)X +1278(unmaps)X +1593(speci\256ed)X +1947(shared)X +2217(memory)X +2552(segment)X +2887(in)X +2997(a)X +3077(typed)X +3314(form)X +3527(from)X +3740(process')X +776 5000(address)N +1061(space)X +1278(indicated)X +1624(by)X +2 f +1734(<integer_ptr>)X +1 f +2249(.)X +3 f +576 5168(shmdt\257oat)N +1 f +976(\()X +2 f +1005(<key>)X +1 f +1240(,)X +2 f +(<\257oat_ptr>)S +1 f +1684(\))X +776 5308(Unlocks)N +1110(and)X +1278(unmaps)X +1593(speci\256ed)X +1947(shared)X +2217(memory)X +2552(segment)X +2887(in)X +2997(a)X +3077(typed)X +3314(form)X +3527(from)X +3740(process')X +776 5420(address)N +1061(space)X +1278(indicated)X +1624(by)X +2 f +1734(<\257oat_ptr>)X +1 f +2156(.)X +3 f +576 5588(shmfree)N +1 f +878(\()X +2 f +907(<key>)X +1 f +1142(\))X +776 5728(Deallocates)N +1209(speci\256ed)X +1544(shared)X +1795(memory)X +2111(segment.)X + +27 p +%%Page: 27 27 +11 s 11 xH 0 xS 1 f +2209 400(-)N +2260(27)X +2370(-)X +3 f +576 688(lock)N +1 f +733(\()X +2 f +762(<resource_name>)X +1 f +1421(,)X +2 f +(<timeout>)S +1 f +1826(\))X +776 828(Permits)N +1070(exclusive)X +1427(access)X +1675(to)X +1768(abstract)X +2067(resource)X +2389(identi\256ed)X +2748(by)X +2861(string-valued)X +2 f +3351(<resource_name>)X +1 f +4010(.)X +776 940(Negative)N +1133(return)X +1382(value)X +1612(indicates)X +1964(resource)X +2299(could)X +2533(not)X +2684(be)X +2805(acquired)X +3146(within)X +3410(speci\256ed)X +3761(timeout)X +776 1052(period.)N +3 f +576 1220(unlock)N +1 f +831(\()X +2 f +860(<resource_name>)X +1 f +1519(\))X +776 1360(Releases)N +1106(lock)X +1280(on)X +1390(previously)X +1784(acquired)X +2109(resource.)X +3 f +576 1528(status)N +1 f +795(\()X +2 f +824(<component_name>)X +1 f +1562(,)X +2 f +(<inum>)S +1 f +1878(,)X +2 f +1922(<stat_ptr>)X +1 f +2315(,)X +2 f +(<loc_ptr>)S +1 f +2710(\))X +776 1668(Takes)N +1034(string)X +1283(valued)X +1566(component)X +2006(name)X +2245(and)X +2420(an)X +2551(instance)X +2888(number)X +3205(and)X +3381(returns)X +3674(the)X +3831(status)X +776 1780(\(0=nonexistent,)N +1354(1=active\))X +1714(and)X +1867(location)X +2178(\(processor)X +2569(number)X +2864(in)X +2959(the)X +3093(range)X +3314(0)X +3384(\320)X +3497(p\))X +3595(of)X +3693(that)X +3851(com-)X +776 1892(ponent)N +1038(instance.)X +3 f +576 2060(entercomp)N +1 f +976(\()X +2 f +1005(<name>)X +1 f +1313(,)X +2 f +(<loc_machine>)S +1 f +1903(,)X +2 f +(<obj_\256le>)S +1 f +2308(,)X +2 f +(<arch>)S +1 f +2609(\))X +776 2200(Permits)N +1077(a)X +1147(component)X +1570(description)X +1993(to)X +2093(be)X +2207(added;)X +2473(specifying)X +2871(the)X +3010(component)X +3433(name,)X +3677(the)X +3816(object)X +776 2312(\256le)N +913(name)X +1128(and)X +1279(the)X +1411(machine)X +1734(on)X +1845(which)X +2083(it)X +2156(is)X +2238(located,)X +2538(and)X +2688(the)X +2819(type)X +2994(of)X +3090(architecture)X +3529(that)X +3685(the)X +3816(object)X +776 2424(will)N +936(execute)X +1227(on.)X +3 f +576 2592(shmstat)N +1 f +868(\()X +2 f +897(<key_ptr_ptr>)X +1 f +1426(,)X +2 f +(<stat_ptr>)S +1 f +1841(\))X +776 2732(Obtains)N +1081(information)X +1529(about)X +1756(shared)X +2016(memory)X +2341(regions.)X +2653(Array)X +2888(of)X +2993(strings)X +3260(holds)X +3483(the)X +3623(key)X +3782(values;)X +776 2844(array)N +987(of)X +1091(integers)X +1401(holds)X +1623(status)X +1855(\(0=free,)X +2167(1=locked\))X +2556(information.)X +3048(Return)X +3319(value)X +3541(speci\256es)X +3874(total)X +776 2956(number)N +1067(of)X +1162(active)X +1395(regions.)X +3 f +576 3124(lockstat)N +1 f +869(\()X +2 f +898(<key_ptr_ptr>)X +1 f +1427(\))X +776 3264(Returns)N +1072(total)X +1252(number)X +1543(of)X +1638(active)X +1871(locks)X +2079(with)X +2258(array)X +2460(of)X +2555(strings)X +2812(holding)X +3104(the)X +3234(key)X +3383(values.)X +3 f +576 3432(Notes:)N +1 f +776 3572(Among)N +1066(the)X +3 f +9 s +1196(PVM)X +1 f +11 s +1386(constructs)X +1769(described)X +2132(above,)X +2390(those)X +2602(concerned)X +2989(with)X +3172(machine)X +3497(dependent)X +3885(data)X +776 3684(representation)N +1304(are)X +1440(to)X +1538(be)X +1650(implemented)X +2141(as)X +2243(part)X +2409(of)X +2511(the)X +2648(installation)X +3071(procedure)X +3451(for)X +3582(architectures)X +776 3796(not)N +922(represented)X +1360(in)X +1462(the)X +1603(generic)X +1895(distribution)X +2336(of)X +2442(the)X +2583(software.)X +2940(Also)X +3139(deemed)X +3446(part)X +3617(of)X +3724(this)X +3886(pro-)X +776 3908(cedure)N +1062(are)X +1221(constructs)X +1630(to)X +1751(handle)X +2038(other)X +2271(data)X +2470(types)X +2708(such)X +2920(as)X +3044(double)X +3335(precision,)X +3731(boolean,)X +776 4020(enumerated)N +1209(types,)X +1439(etc.)X + +27 p +%%Trailer +xt + +xs |