/Users/andrea/_magisterarbeit/korpus/clean/trainkorpus/1/file_209.html NN ----------------------------------------- : Updated VVN . SENT 29 CD January NP 1998 CD Challenges NNS in IN Designing NP an DT HPF NP DebuggerDavid NP C NP . SENT P NN . SENT LaFrance NP Linden NP Abstract JJ High NP Performance NP Fortran NP HPF NP provides VVZ directive NN based VVN data NNS parallel JJ extensions NNS to TO Fortran NP 90 CD . SENT To TO achieve VV parallelism NN , , Digital NP s PP HPF NP compiler NN transforms VVZ a DT user NN s PP program NN to TO run VV as IN several JJ intercommunicating VVG processes NNS . SENT The DT ultimate JJ goal NN of IN an DT HPF NP debugger NN is VBZ to TO present VV the DT user NN with IN a DT single JJ source NN level NN view NN of IN the DT program NN at IN the DT control NN flow NN and CC data NN levels NNS . SENT Since IN pieces NNS of IN the DT program NN are VBP running VVG in IN several JJ different JJ processes NNS , , the DT task NN is VBZ to TO reconstruct VV the DT single JJ control NN and CC data NN views NNS . SENT This DT paper NN presents VVZ several JJ of IN the DT challenges NNS involved VVN and CC how WRB an DT experimental JJ debugging VVG technology NN , , code NN named VVD Aardvark NN , , successfully RB addresses VVZ many JJ of IN them PP . SENT Introduction NN As IN we PP learn VVP better JJR ways NNS to TO express VV our PP$ thoughts NNS in IN the DT form NN of IN computer NN programs NNS and CC to TO take VV better JJR advantage NN of IN hardware NN resources NNS , , we PP incorporate VV these DT ideas NNS and CC paradigms NNS into IN the DT programming NN languages NNS we PP use VVP . SENT Fortran NP 901 CD , , 2 CD provides VVZ mechanisms NNS to TO operate VV directly RB on IN arrays NNS , , e NN . SENT g NN . SENT , , A DT 2 CD A NP to TO double VV each DT element NN of IN A DT independent JJ of IN rank NN , , rather RB than IN requiring VVG the DT programmer NN to TO operate VV on IN individual JJ elements NNS within IN nested VVD DO VV loops NNS . SENT Many JJ of IN these DT mechanisms NNS are VBP naturally RB data NNS parallel JJ . SENT High NP Performance NP Fortran NP HPF NP 3 CD , , 4 CD extends VVZ Fortran NP 90 CD with IN data NN distribution NN directives NNS to TO facilitate VV computations NNS done VVN in IN parallel NN . SENT Debuggers NP , , in IN turn NN , , need VVP to TO be VB enhanced VVN to TO keep VV pace NN with IN new JJ features NNS of IN the DT languages NNS . SENT The DT fundamental JJ user NN requirement NN , , however RB , , remains VVZ the DT same JJ . SENT Present VV the DT control NN flow NN of IN the DT program NN and CC its PP$ data NNS in IN terms NNS of IN the DT original JJ source NN , , independent JJ of IN what WP the DT compiler NN has VHZ done VVN or CC what WP is VBZ happening VVG in IN the DT run VVN time NN support NN . SENT Since IN HPF NP compilers NNS automatically RB distribute VVP data NNS and CC computation NN , , thereby RB widening VVG the DT gap NN between IN actual JJ execution NN and CC original JJ source NN , , meeting VVG this DT requirement NN is VBZ both DT more RBR important JJ and CC more RBR difficult JJ . SENT This DT paper NN describes VVZ several JJ of IN the DT challenges NNS HPF NP creates VVZ for IN a DT debugger NN and CC how WRB an DT experimental JJ debugging VVG technology NN , , internally RB code VV named VVN Aardvark NN , , successfully RB addresses VVZ many JJ of IN them PP using VVG techniques NNS that WDT have VHP applicability NN beyond IN HPF NP . SENT For IN example NN , , programming NN paradigms NNS common JJ to TO explicit JJ message NN passing VVG systems NNS such JJ as IN the DT Message NP Passing NN Interface NP MPI NP 5 CD 7 CD can MD benefit VV from IN Aardvark NN s PP methods NNS . SENT The DT HPF NP compiler NN and CC run NN time NN used VVN is VBZ DIGITAL JJ s PP HPF NP compiler NN , , 8 CD which WDT produces VVZ an DT executable JJ that WDT uses VVZ the DT run VVN time NN support NN of IN DIGITAL JJ s PP Parallel VV Software NP Environment NP . SENT 9 CD Digital NP s PP HPF NP compiler NN transforms VVZ a DT program NN to TO run VV as IN several JJ intercommunicating VVG processes NNS . SENT The DT fundamental JJ requirement NN , , then RB , , is VBZ to TO give VV the DT appearance NN of IN a DT single JJ control NN flow NN and CC a DT single JJ data NN space NN , , even RB though IN there EX are VBP several JJ individual JJ control NN flows NNS and CC the DT data NN has VHZ been VBN distributed VVN . SENT In IN the DT paper NN , , I PP introduce VV the DT concept NN of IN logical JJ entities NNS and CC show VV how WRB they PP address VVP many JJ of IN the DT control NN flow NN challenges NNS . SENT A DT discussion NN of IN a DT rich JJ and CC flexible JJ data NNS model NN that WDT easily RB handles VVZ distributed VVN data NN follows VVZ . SENT I PP then RB point VVP out IN difficulties NNS imposed VVN on IN user NN interfaces NNS , , especially RB when WRB the DT program NN is VBZ not RB in IN a DT completely RB consistent JJ state NN , , and CC indicate VV how WRB they PP can MD be VB overcome VVN . SENT Sections NNS on IN related JJ work NN and CC the DT applicability NN of IN logical JJ entities NNS to TO other JJ areas NNS conclude VVP the DT paper NN . SENT Logical JJ Entities NNS From IN the DT programmer NN s PP perspective NN , , an DT HPF NP program NN is VBZ a DT single JJ process NN thread NN with IN a DT single JJ control NN flow NN represented VVN by IN a DT single JJ call NN stack VV consisting VVG of IN single JJ stack NN frames NNS . SENT A DT debugger NN should MD strive VV to TO present VV the DT program NN in IN terms NNS of IN these DT single JJ entities NNS . SENT A DT key JJ enabling VVG concept NN in IN the DT Aardvark NN debugger NN is VBZ the DT definition NN of IN logical JJ entities NNS in IN addition NN to TO traditional JJ physical JJ entities NNS . SENT Generally RB , , a DT logical JJ entity NN collects VVZ several JJ physical JJ entities NNS into IN a DT single JJ entity NN . SENT Many JJ parts NNS of IN Aardvark NN are VBP unaware JJ of IN whether IN or CC not RB an DT entity NN is VBZ logical JJ or CC physical JJ , , and CC a DT debugger NN s PP user NN interface NN uses VVZ logical JJ entities NNS to TO present VV program NN state NN . SENT A DT physical JJ entity NN is VBZ something NN that WDT exists VVZ somewhere RB outside IN the DT debugger NN . SENT A DT physical JJ process NN exists VVZ within IN the DT operating VVG system NN and CC has VHZ memory NN that WDT can MD be VB read VVN and CC written VVN . SENT A DT physical JJ thread NN has VHZ registers NNS and CC through IN registers NNS and CC process NN memory NN a DT call NN stack VV . SENT A DT physical JJ stack NN frame NN has VHZ a DT program NN counter NN , , a DT caller NN stack VV frame NN , , and CC a DT callee NN stack VV frame NN . SENT Each DT of IN these DT has VHZ a DT representation NN within IN the DT debugger NN , , but CC the DT actual JJ entity NN exists VVZ outside IN the DT debugger NN . SENT A DT logical JJ entity NN is VBZ an DT abstraction NN that WDT exists VVZ within IN the DT debugger NN . SENT Logical JJ entities NNS generally RB group NN together RB several JJ related JJ physical JJ entities NNS and CC synthesize VV a DT single JJ behavior NN from IN them PP . SENT In IN C NP terms NNS , , a DT process NN is VBZ an DT abstract JJ base NN class NN . SENT physical JJ and CC logical JJ processes NNS are VBP derived VVN classes NNS . SENT A DT logical JJ process NN contains VVZ as IN data NN members NNS a DT set NN of IN other JJ probably RB physical JJ processes NNS . SENT The DT methods NNS of IN a DT logical JJ process NN , , e NN . SENT g NN . SENT , , to TO set VV a DT breakpoint NN , , bring VVP about IN the DT desired VVN operations NNS using VVG logical JJ algorithms NNS rather RB than IN physical JJ algorithms NNS . SENT The DT logical JJ algorithms NNS often RB work VVP by IN invoking VVG the DT same JJ operation NN on IN the DT physical JJ entities NNS and CC constructing VVG a DT logical JJ entity NN from IN the DT physical JJ pieces NNS . SENT This DT implies VVZ that IN some DT operations NNS on IN physical JJ entities NNS can MD be VB done VVN in IN isolation NN from IN their PP$ logical JJ containers NNS . SENT Aardvark NN makes VVZ a DT stronger JJR statement NN . SENT Physical JJ entities NNS are VBP the DT building NN blocks NNS for IN logical JJ entities NNS and CC are VBP first JJ class NN objects NNS in IN their PP$ own JJ right NN . SENT This DT allows VVZ physical JJ entities NNS to TO be VB used VVN for IN traditional JJ debugging VVG without IN any DT additional JJ structure NN . SENT 10 CD A NP positive JJ consequence NN of IN this DT object NN oriented JJ design NN is VBZ that IN a DT user NN interface NN can MD often RB be VB unaware JJ of IN the DT physical JJ or CC logical JJ nature NN of IN the DT entities NNS it PP is VBZ managing VVG . SENT For IN example NN , , it PP can MD set VV a DT breakpoint NN in IN a DT process NN or CC navigate VV a DT thread NN s PP stack VV by IN calling VVG virtual JJ methods NNS declared VVD on IN the DT base NN classes NNS . SENT Some DT interesting JJ design NN questions NNS arise VVP . SENT What WP is VBZ a DT process NN . SENT What WP is VBZ a DT thread NN . SENT What WP is VBZ a DT stack NN frame NN . SENT What WP operations NNS are VBP expected VVN to TO work VV on IN all DT kinds NNS of IN processes NNS but CC actually RB only RB work VV on IN physical JJ processes NNS . SENT Experience NN to TO date NN is VBZ inconclusive JJ . SENT Aardvark NN currently RB defines VVZ the DT base NN classes NNS and CC methods NNS for IN logical JJ entities NNS to TO include VV many JJ things NNS that WDT are VBP probably RB specific JJ to TO physical JJ entities NNS . SENT This DT design NN was VBD done VVN largely RB for IN convenience NN . SENT Sometimes RB a DT logical JJ entity NN is VBZ little RB more JJR than IN a DT container NN of IN physical JJ entities NNS . SENT A DT logical JJ stack VV frame NN for IN threads NNS that WDT are VBP in IN unrelated JJ functions NNS simply RB collects VVZ the DT unrelated JJ physical NN stack VV frames NNS . SENT Nevertheless RB , , logical JJ stack NN frames NNS provide VVP a DT consistent JJ mechanism NN for IN collecting VVG physical JJ stack NN frames NNS , , and CC variants NNS of IN logical JJ stack NN frames NNS can MD discriminate VV how WRB coordinated VVN the DT physical JJ threads NNS are VBP . SENT The DT concept NN of IN logical JJ entities NNS does VVZ not RB apply VV to TO all DT cases NNS , , though RB . SENT Variables NNS have VHP values NNS , , and CC there EX does VVZ not RB seem VV to TO be VB anything NN logical JJ or CC physical JJ about IN values NNS . SENT Yet RB , , if IN a DT replicated VVN variable NN s PP values VVZ on IN different JJ processors NNS are VBP different JJ , , there EX is VBZ no DT single JJ value NN and CC some DT mechanism NN is VBZ needed VVN . SENT Rather RB than IN define VV logical JJ values NNS , , Aardvark NN provides VVZ a DT differing VVG values NNS mechanism NN , , which WDT is VBZ discussed VVN in IN a DT later JJR section NN of IN the DT same JJ name NN . SENT Controlling VVG an DT HPF NP Process NN Users NNS want VVP to TO be VB able JJ to TO start VV and CC stop VV HPF NP programs NNS , , set VVN breakpoints NNS , , and CC single JJ step NN . SENT From IN a DT user NN interface NN and CC the DT higher JJR levels NNS of IN Aardvark NN , , these DT tasks NNS are VBP simple JJ to TO accomplish VV ask VV the DT process NN or CC thread NN , , which WDT happens VVZ to TO be VB logical JJ , , to TO perform VV the DT operation NN . SENT Within IN the DT logical JJ process NN or CC thread NN , , however RB , , the DT complexity NN varies VVZ , , depending VVG on IN the DT operation NN . SENT Starting VVG and CC Stopping VVG Starting VVG and CC stopping VVG a DT logical JJ thread NN is VBZ straightforward JJ . SENT Start VV or CC stop VV each DT component NN physical JJ thread NN . SENT Some DT race NN conditions NNS require VVP care NN in IN coding VVG , , though RB . SENT For IN example NN , , starting VVG a DT logical JJ thread NN theoretically RB starts VVZ all PDT the DT corresponding JJ physical JJ threads NNS simultaneously RB . SENT In IN practice NN , , Aardvark NN serializes VVZ the DT physical JJ threads NNS . SENT In IN Figure NP 1 CD , , when WRB all PDT the DT physical JJ threads NNS stop VVP , , the DT logical JJ thread NN is VBZ declared VVN to TO be VB stopped VVN . SENT Aardvark NN then RB starts VVZ the DT logical JJ thread NN at IN time NN and CC proceeds NNS to TO start VV each DT physical JJ thread NN . SENT Suppose VV the DT first JJ physical JJ thread NN thread NN 0 CD stops NNS immediately RB , , at IN time NN . SENT It PP might MD appear VV that IN the DT logical JJ thread NN is VBZ now RB stopped VVN because IN each DT physical JJ thread NN is VBZ stopped VVN . SENT This DT scenario NN does VVZ not RB take VV into IN account NN that IN the DT other JJ physical JJ threads NNS have VHP not RB yet RB been VBN started VVN . SENT Timestamping NP execution NN state NN transitions NNS , , i NP . SENT e SYM . SENT , , ordering VVG the DT events NNS as RB observed VVD by IN Aardvark NN , , works VVZ well RB . SENT a DT logical JJ thread NN becomes VVZ stopped VVN only RB when WRB all PDT its PP$ physical JJ threads NNS have VHP stopped VVN after IN the DT time NN that IN the DT logical JJ thread NN was VBD started VVN . SENT An DT added JJ complexity NN is VBZ that IN some DT reasons NNS for IN stopping VVG a DT physical JJ thread NN should MD stop VV the DT other JJ physical JJ threads NNS and CC the DT logical JJ thread NN . SENT In IN this DT case NN , , pending VVG starts NNS should MD be VB cancelled VVN . SENT Figure NN 1 CD Determining VVG When WRB a DT Logical JJ Thread NN Stops NP Breakpoints NNS Setting NP a DT breakpoint NN in IN a DT logical JJ process NN sets VVZ a DT breakpoint NN in IN each DT physical JJ process NN and CC collects VVZ the DT physical JJ breakpoint NN representations NNS into IN a DT logical JJ breakpoint NN . SENT For IN HPF NP , , any DT action NN or CC conditional JJ expression NN is VBZ associated VVN with IN the DT logical JJ breakpoint NN , , not RB with IN the DT physical JJ breakpoints NNS . SENT Consider VV the DT expression NN ARRAY NN 3 CD , , 4 CD . SENT LT NP . SENT 5 LS . SENT Even RB if IN the DT element NN is VBZ stored VVN in IN only RB one CD process NN , , the DT entire JJ HPF NP process NN needs VVZ to TO stop VV before IN the DT expression NN is VBZ evaluated VVN . SENT otherwise RB , , there EX is VBZ the DT potential NN for IN incorrect JJ data NNS to TO be VB read VVN or CC for IN processes NNS to TO continue VV running VVG when WRB they PP should MD not RB . SENT This DT requires VVZ each DT physical JJ process NN to TO reach VV its PP$ physical JJ breakpoint NN before IN the DT expression NN can MD be VB evaluated VVN . SENT Once RB evaluated VVN , , the DT process NN remains VVZ stopped VVN or CC continues VVZ , , depending VVG on IN the DT result NN . SENT For IN HPF NP , , a DT breakpoint NN in IN a DT logical JJ process NN implies VVZ a DT global JJ barrier NN of IN the DT physical JJ processes NNS . SENT Recognizing VVG and CC processing VVG a DT thread NN reaching VVG a DT logical JJ breakpoint NN is VBZ somewhat RB involved VVN . SENT Aardvark NN s PP general JJ mechanism NN for IN breakpoint NN determination NN is VBZ to TO ask VV the DT thread NN s PP operating VVG system NN model NN if IN the DT initial JJ stop NN reason NN could MD be VB a DT breakpoint NN . SENT If IN this DT is VBZ the DT case NN , , the DT operating VVG system NN model NN provides VVZ a DT comparison NN key NN for IN further JJR processing NN . SENT For IN physical JJ DIGITAL JJ UNIX NP threads NNS , , a DT SIGTRAP NP signal NN could MD be VB a DT breakpoint NN , , with IN the DT comparison NN key NN being VBG the DT program NN counter NN address NN of IN the DT potential JJ breakpoint NN instruction NN . SENT This DT comparison NN key NN is VBZ then RB used VVN to TO search VV the DT breakpoints NNS installed VVN in IN the DT physical JJ process NN to TO determine VV which WDT if IN any DT breakpoint NN was VBD reached VVN . SENT If IN a DT breakpoint NN was VBD reached VVN , , the DT stop NN reason NN is VBZ updated VVN to TO be VB stopped VVN at IN breakpoint NN . SENT All PDT this DT physical JJ processing NN happens VVZ before IN the DT logical JJ algorithms NNS have VHP a DT chance NN to TO notice VV that IN the DT physical JJ thread NN has VHZ stopped VVN . SENT Therefore RB , , by IN the DT time NN Aardvark NN determines VVZ that IN a DT logical JJ thread NN has VHZ stopped VVN , , any DT physical JJ threads NNS that WDT are VBP stopped VVN at IN a DT breakpoint NN have VHP had VHN their PP$ stop NN reasons NNS updated VVN . SENT For IN a DT logical JJ thread NN , , the DT initial JJ logical JJ stop NN reason NN could MD be VB a DT breakpoint NN if IN each DT of IN the DT physical JJ threads NNS is VBZ stopped VVN at IN a DT breakpoint NN , , as RB shown VVN in IN Figure NP 2 CD . SENT The DT comparison NN key NN in IN this DT case NN is VBZ the DT logical JJ stop NN reason NN itself PP . SENT The DT breakpoints NNS of IN the DT component NN stop NN reasons NNS are VBP then RB compared VVN to TO the DT component NN breakpoints NNS of IN the DT installed JJ logical JJ breakpoints NNS to TO determine VV if IN a DT logical JJ breakpoint NN was VBD reached VVN . SENT If IN there EX is VBZ a DT match NN , , the DT logical JJ thread NN s PP stop VVP reason NN is VBZ updated VVN . SENT Figure NN 2 CD Logical JJ Breakpoint NN Determination NN Aardvark NN achieves VVZ the DT flexibility NN of IN vastly RB different JJ types NNS of IN comparison NN keys NNS machine NN addresses NNS and CC logical JJ stop NN reasons NNS by IN having VHG the DT comparison NN key JJ type NN be VB the DT most RBS basic JJ Aardvark NN base NN class NN , , which WDT is VBZ the DT equivalent NN of IN Java NP s PP Object VVP class NN , , and CC by IN using VVG run VVN time NN typing VVG as RB necessary JJ . SENT Single JJ Stepping JJ Single NP stepping VVG a DT logical JJ thread NN is VBZ accomplished VVN by IN single JJ stepping VVG the DT physical JJ threads NNS . SENT It PP is VBZ not RB sufficient JJ to TO single JJ step NN the DT first JJ thread NN , , wait VV for IN it PP to TO stop VV , , and CC then RB proceed VV with IN the DT other JJ threads NNS . SENT If IN the DT program NN statement NN requires VVZ communication NN , , then RB the DT entire JJ HPF NP program NN needs VVZ to TO be VB running VVG to TO bring VV about IN the DT communication NN . SENT This DT implies VVZ that IN single JJ stepping VVG is VBZ a DT two CD part NN process NN initiate VV and CC wait VV and CC that IN the DT initiation NN mechanism NN must MD be VB part NN of IN the DT exposed VVN interface NN of IN threads NNS . SENT As IN background NN , , running VVG a DT thread NN in IN Aardvark NN involves VVZ continuing VVG the DT thread NN with IN a DT run NN reason NN . SENT The DT run NN reason NN is VBZ empowered VVN to TO take VV the DT actions NNS e NN . SENT g NN . SENT , , setting VVG or CC enabling VVG temporary JJ breakpoints NNS necessary JJ to TO carry VV out RP its PP$ task NN . SENT In IN this DT paper NN , , the DT word NN empowered VVN means NNS that IN the DT reason NN has VHZ a DT method NN that WDT will MD be VB called VVN to TO do VV reason NN specific JJ actions NNS to TO accomplish VV the DT reason NN s PP semantics NNS . SENT This DT relieves VVZ user NN interfaces NNS and CC other JJ clients NNS from IN figuring VVG out RP how WRB to TO accomplish VV tasks NNS . SENT As IN a DT result NN , , Aardvark NN defines VVZ a DT get VVP single JJ stepping VVG run NN reason NN method NN for IN threads NNS . SENT Clients NNS use VVP the DT resulting VVG run NN reason NN to TO continue VV the DT thread NN , , thereby RB initiating VVG the DT single JJ step NN operation NN . SENT Therefore RB , , single JJ stepping VVG a DT logical JJ thread NN in IN Aardvark NN involves VVZ calling VVG the DT logical JJ thread NN s PP get VVP single JJ stepping VVG run NN reason NN method NN , , continuing VVG the DT thread NN with IN the DT result NN , , and CC waiting VVG for IN the DT thread NN to TO stop VV . SENT The DT get VVP single JJ stepping VVG run NN reason NN method NN for IN a DT logical JJ thread NN in IN turn NN calls VVZ the DT get VVP single JJ stepping VVG run NN reason NN method NN of IN the DT component NN physical JJ threads NNS and CC collects VVZ the DT physical JJ results NNS into IN a DT logical JJ single JJ stepping JJ run NN reason NN . SENT When WRB invoked VVN , , the DT logical JJ reason NN continues VVZ each DT physical JJ thread NN with IN its PP$ corresponding JJ physical JJ reason NN . SENT Single JJ stepping VVG dramatically RB demonstrates VVZ the DT autonomy NN of IN the DT physical JJ entities NNS . SENT When WRB continuing VVG a DT logical JJ thread NN with IN a DT logical JJ single JJ stepping JJ run NN reason NN , , the DT physical JJ threads NNS can MD start VV , , stop VV , , and CC be VB continued VVN asynchronously RB to TO each DT other JJ and CC without IN any DT intervention NN from IN a DT user NN interface NN , , the DT logical JJ entities NNS , , or CC other JJ clients NNS . SENT This DT is VBZ especially RB true JJ if IN the DT thread NN was VBD stopped VVN at IN a DT breakpoint NN . SENT In IN this DT case NN , , continuing VVG a DT physical JJ thread NN involves VVZ replacing VVG the DT original JJ instruction NN , , machine NN single JJ stepping VVG , , putting VVG back RB the DT breakpoint NN instruction NN , , and CC then RB continuing VVG with IN the DT original JJ run NN reason NN . SENT Empowering VVG run NN reasons NNS and CC stop VV reasons NNS to TO effect VV the DT necessary JJ state NN transitions NNS enables VVZ physical JJ entities NNS to TO be VB autonomous JJ , , thus RB relieving VVG the DT logical JJ algorithms NNS from IN enormous JJ potential JJ complexity NN . SENT Coordinating VVG Physical JJ Entities NNS The DT previous JJ discussion NN describes VVZ some DT logical JJ algorithms NNS . SENT The DT section NN Starting VVG and CC Stopping NN describes VVZ using VVG timestamps NNS to TO determine VV when WRB a DT logical JJ thread NN becomes VVZ stopped VVD see VV Figure NP 1 CD , , and CC the DT section NN Breakpoints NNS describes VVZ a DT logical JJ thread NN possibly RB reaching VVG a DT breakpoint NN see VVP Figure NP 2 CD . SENT The DT physical JJ entities NNS need VVP to TO be VB coordinated VVN so RB that IN the DT logical JJ algorithms NNS can MD be VB run VVN . SENT In IN Aardvark NN , , this DT is VBZ done VVN with IN a DT process NN change NN handler NN . SENT A DT process NN change NN handler NN is VBZ a DT set NN of IN callbacks NNS that IN a DT client NN registers NNS with IN a DT process NN and CC its PP$ threads NNS , , allowing VVG the DT client NN to TO be VB notified VVN of IN state NN changes NNS . SENT For IN example NN , , if IN a DT user NN interface NN is VBZ notified VVN that IN a DT thread NN has VHZ stopped VVN and CC that IN the DT reason NN is VBZ a DT UNIX NP signal NN , , the DT user NN interface NN can MD look VV up RP the DT signal NN in IN a DT table NN to TO determine VV if IN it PP should MD continue VV the DT thread NN possibly RB discarding VVG the DT actual JJ signal NN or CC if IN it PP should MD keep VV the DT thread NN stopped VVD . SENT In IN the DT context NN of IN HPF NP , , a DT user NN interface NN registers NNS its PP$ process NN change NN handler NN with IN the DT logical JJ HPF NP process NN . SENT During IN construction NN of IN the DT logical JJ process NN , , Aardvark NN registers NNS a DT physical NN to TO logical JJ process NN change NN handler NN with IN the DT physical JJ processes NNS . SENT It PP is VBZ this DT physical JJ to TO logical JJ handler NN that WDT coordinates VVZ the DT physical JJ entities NNS . SENT When WRB the DT first JJ physical JJ thread NN stops NNS , , as RB at IN time NN in IN Figure NP 1 CD , , the DT handler NN is VBZ notified VVN but CC notices NNS that IN the DT timestamps NNS do VVP not RB indicate VV that IN the DT logical JJ thread NN should MD be VB considered VVN to TO have VH stopped VVN . SENT When WRB the DT last JJ physical JJ thread NN stops NNS , , the DT handler NN then RB synthesizes VVZ a DT stopped VVN at IN collection NN logical JJ stop NN reason NN , , as RB in IN Figure NP 2 CD , , and CC informs VVZ the DT logical JJ thread NN that IN it PP has VHZ stopped VVN . SENT Aardvark NN defines VVZ some DT callbacks NNS in IN process NN change NN handlers NNS that WDT are VBP for IN HPF NP and CC other JJ logical JJ paradigms NNS . SENT These DT callbacks NNS allow VVP a DT user NN interface NN to TO implement VV policies NNS when WRB a DT thread NN or CC process NN goes VVZ into IN an DT intermediate JJ state NN . SENT For IN example NN , , at IN time NN in IN Figure NP 1 CD a DT physical JJ thread NN has VHZ stopped VVN but CC the DT logical JJ thread NN is VBZ not RB yet RB stopped VVN . SENT Whenever WRB a DT physical JJ thread NN stops NNS , , the DT handler NN s PP component NN thread NN stopped VVD callback NN is VBZ invoked VVN . SENT A DT possible JJ user NN interface NN policy NN is VBZ 11 CD If IN the DT component NN thread NN stopped VVN for IN a DT nasty JJ reason NN , , such JJ as IN an DT arithmetic NN error NN , , try VVP to TO stop VV all PDT the DT other JJ component NN threads NNS immediately RB in IN order NN to TO minimize VV divergence NN among IN the DT physical JJ entities NNS . SENT If IN this DT is VBZ the DT first JJ component NN thread NN that WDT stopped VVD for IN a DT nice JJ reason NN , , such JJ as IN reaching VVG a DT breakpoint NN , , start VVP a DT timer NN to TO wait VV for IN the DT other JJ component NN threads NNS to TO stop VV . SENT If IN the DT timer NN goes VVZ off RP before IN all PDT the DT other JJ component NN threads NNS have VHP stopped VVN , , try VVP to TO stop VV them PP because IN it PP looks VVZ like IN they PP are VBP not RB going VVG to TO stop VV on IN their PP$ own JJ . SENT If IN this DT is VBZ the DT last JJ component NN thread NN , , cancel VV any DT timers NNS . SENT The DT user NN interface NN can MD provide VV the DT means NN for IN the DT user NN to TO define VV the DT timer NN interval NN , , as RB well RB as IN other JJ attributes NNS of IN policies NNS . SENT These DT policies NNS and CC their PP$ control NN mechanisms NNS are VBP not RB the DT responsibility NN of IN the DT debug VV engine NN . SENT Examining VVG an DT HPF NP Call NP Stack NP When WRB an DT HPF NP program NN stops NNS , , the DT user NN wants VVZ to TO see VV a DT call NN stack NN that WDT appears VVZ to TO be VB a DT single JJ thread NN of IN control NN . SENT Sometimes RB this DT is VBZ not RB possible JJ , , but CC even RB in IN those DT cases NNS , , a DT debugger NN can MD offer VV a DT fair JJ amount NN of IN assistance NN . SENT The DT HPF NP language NN provides VVZ some DT mechanisms NNS that WDT also RB need VVP to TO be VB considered VVN . SENT The DT EXTRINSIC JJ HPF NP LOCAL JJ procedure NN type NN allows VVZ procedures NNS written VVN in IN Fortran NP 90 CD to TO operate VV on IN the DT local JJ portion NN of IN distributed VVN data NNS . SENT This DT type NN is VBZ useful JJ for IN computational JJ kernels NNS that IN cannot NN be VB expressed VVN in IN a DT data NN parallel NN fashion NN and CC do VVP not RB require VV communication NN . SENT The DT EXTRINSIC JJ HPF NP SERIAL JJ procedure NN type NN allows VVZ data NNS to TO be VB mapped VVN to TO a DT single JJ process NN that WDT runs VVZ the DT procedure NN . SENT This DT type NN is VBZ useful JJ for IN calling VVG inherently RB serial JJ code NN , , including VVG user NN interfaces NNS , , which WDT may MD not RB be VB written VVN in IN Fortran NP . SENT DIGITAL JJ s PP HPF NP compiler NN also RB supports VVZ twinning VVG , , which WDT allows VVZ serial JJ code NN to TO call VV parallel JJ HPF NP code NN . SENT All PDT these DT mechanisms NNS affect VVP the DT call NN stack VV or CC how WRB a DT user NN navigates VVZ the DT call NN stack VV . SENT They PP require VVP underlying JJ support NN from IN the DT debugger NN as RB well RB as IN user NN interface NN support NN . SENT Logical JJ Stack NP Frames NP Aardvark NN s PP logical JJ entity NN model NN applies VVZ to TO stack VV frames NNS . SENT logical JJ stack NN frames NNS collect VVP several JJ physical NN stack VV frames NNS and CC present VV a DT synthesized VVN view NN of IN the DT logical JJ call NN stack VV . SENT Currently RB , , Aardvark NN defines VVZ four CD types NNS of IN logical JJ stack VV frames NNS to TO represent VV different JJ scenarios NNS that WDT can MD be VB encountered VVN . SENT 1 LS . SENT Scalar NN , , in IN which WDT only RB one CD physical JJ thread NN is VBZ semantically RB active JJ 2 CD . SENT Synchronized VVN , , in IN which WDT all DT the DT threads NNS are VBP at IN the DT same JJ place NN in IN the DT same JJ function NN 3 CD . SENT Unsynchronized JJ , , in IN which WDT all DT the DT threads NNS are VBP in IN the DT same JJ function NN but CC at IN different JJ places NNS 4 CD . SENT Multi NNS , , in IN which WDT no DT discernible JJ relationship NN exists VVZ between IN the DT corresponding JJ physical JJ threads NNS Aardvark NN s PP task NN is VBZ to TO discover VV the DT proper JJ alignment NN of IN the DT physical JJ frames NNS of IN the DT physical JJ threads NNS , , determine VV which WDT variant NN of IN logical JJ frame NN to TO use VV in IN each DT case NN , , and CC link VV them PP together RB into IN a DT call NN stack VV . SENT Ideally RB , , all DT logical JJ frames NNS are VBP synchronized VVN , , which WDT means VVZ that IN the DT program NN is VBZ in IN a DT well RB defined VVN state NN . SENT This DT is VBZ true JJ most JJS of IN the DT time NN with IN HPF NP . SENT the DT Single NP Program NN Multiple NN Data NP SPMD NP nature NN of IN HPF NP causes VVZ all DT threads NNS to TO make VV the DT same JJ procedure NN calls NNS from IN the DT same JJ place NN , , and CC breakpoints NNS are VBP barriers NNS causing VVG the DT threads NNS to TO stop VV at IN the DT same JJ place NN . SENT Aardvark NN s VVZ alignment NN process NN starts VVZ at IN the DT outermost JJ stack VV frames NNS of IN the DT physical JJ threads NNS the DT ones NNS near IN the DT Fortran NP PROGRAM NN unit NN and CC then RB progressively RB examines VVZ the DT callees NNS toward IN where WRB the DT program NN stopped VVD . SENT Starting VVG from IN the DT innermost JJ frames NNS is VBZ an DT error NN prone JJ approach NN . SENT If IN the DT innermost JJ frames NNS are VBP in IN different JJ functions NNS , , Aardvark NN might MD construct VV a DT multiframe NN when WRB the DT frames NNS are VBP actually RB misaligned JJ because IN the DT physical JJ stacks NNS have VHP different JJ depths NNS . SENT As IN discussed VVN in IN the DT section NN on IN twinning VVG , , depth NN is VBZ not RB a DT reliable JJ alignment NN mechanism NN either RB . SENT Starting VVG at IN the DT outermost JJ frames NNS follows VVZ the DT temporal JJ order NN of IN calls NNS and CC also RB correctly RB handles VVZ recursive JJ procedures NNS . SENT The DT disadvantage NN of IN starting VVG at IN the DT outermost JJ frames NNS is VBZ that IN each DT physical JJ thread NN s PP entire JJ stack NN must MD be VB determined VVN before IN the DT logical JJ stack NN can MD be VB constructed VVN . SENT Usually RB the DT programmer NN only RB wants VVZ the DT innermost JJ few JJ frames NNS , , so RB time NN delays NNS in IN the DT construction NN process NN can MD reduce VV the DT ease NN of IN use NN of IN the DT debugger NN . SENT 12 CD Much RB of IN the DT time NN , , the DT physical JJ stack NN frames NNS are VBP at IN the DT same JJ place NN because IN the DT SPMD NP nature NN of IN HPF NP causes VVZ the DT physical JJ threads NNS to TO have VH the DT same JJ control NN flow NN . SENT When WRB a DT procedure NN is VBZ called VVN , , each DT thread NN executes VVZ the DT call NN and CC executes VVZ it PP from IN the DT same JJ place NN . SENT A DT logical JJ breakpoint NN is VBZ reached VVN when WRB the DT physical JJ threads NNS are VBP stopped VVN at IN the DT same JJ place NN at IN the DT corresponding JJ physical JJ breakpoints NNS . SENT These DT cases NNS lead VVP to TO synchronized VVN frames NNS . SENT The DT most RBS common JJ cause NN of IN an DT unsynchronized JJ frame NN is VBZ interrupting VVG the DT program NN during IN a DT computation NN . SENT Even RB in IN this DT case NN , , the DT divergence NN is VBZ usually RB not RB very RB large JJ . SENT One CD reason NN for IN a DT multiframe NN is VBZ the DT interruption NN of IN the DT program NN while IN it PP is VBZ communicating VVG data NNS between IN processes NNS . SENT In IN this DT case NN , , the DT code NN paths NNS can MD easily RB diverge VV , , depending VVG on IN which WDT threads NNS are VBP sending VVG , , which WDT are VBP receiving VVG , , and CC how WRB much JJ data NNS needs VVZ to TO be VB moved VVN . SENT Scalar JJ frames NNS are VBP created VVN because IN of IN the DT semantic JJ flow NN of IN the DT program NN . SENT the DT main JJ program NN unit NN is VBZ written VVN in IN either CC a DT serial JJ language NN or CC an DT HPF NP procedure NN called VVD an DT EXTRINSIC JJ HPF NP SERIAL JJ procedure NN type NN . SENT The DT result NN of IN the DT alignment NN algorithm NN is VBZ a DT set NN of IN frames NNS collected VVN into IN a DT call NN stack VV . SENT The DT normal JJ navigation NN operations NNS e NN . SENT g NN . SENT , , up RB and CC down RB apply VV . SENT Variable JJ lookup NN and CC expression NN evaluation NN work NN as IN expected VVN , , also RB . SENT Variable JJ lookup NN works VVZ best JJS for IN synchronized VVN frames NNS and CC , , for IN HPF NP , , works VVZ for IN unsynchronized JJ frames NNS as IN well RB . SENT For IN multiframes NNS , , variable JJ lookup NN generally RB fails VVZ because IN a DT variable JJ name NN VAR NN may MD resolve VV to TO different JJ program NN variables NNS in IN the DT corresponding JJ physical JJ frames NNS or CC may MD not RB resolve VV to TO anything NN at IN all DT in IN some DT frames NNS . SENT This DT failure NN is VBZ not RB because RB of IN a DT lack NN of IN information NN from IN the DT compiler NN but CC rather RB because IN multiframes NNS are VBP generally RB not RB a DT context NN in IN which WDT a DT string NN VAR NN has VHZ a DT well RB defined VVN semantic JJ . SENT Experience NN to TO date NN suggests VVZ that DT multiframes NNS are VBP of IN interest NN largely RB to TO the DT people NNS developing VVG the DT run VVN time NN support NN for IN data NN motion NN . SENT Nevertheless RB , , the DT point NN of IN transition NN from IN synchronized VVN to TO unsynchronized JJ to TO multi NNS tells VVZ the DT user NN where WRB control NN flows NNS diverged VVD , , and CC this DT information NN can MD be VB very RB valuable JJ . SENT Narrowing VVG Focus NP Using VVG the DT previously RB mentioned VVN techniques NNS sometimes RB results NNS in IN a DT cluttered JJ view NN of IN the DT state NN of IN the DT entire JJ program NN and CC difficulty NN in IN finding VVG relevant JJ information NN . SENT Aardvark NN provides VVZ two CD ways NNS to TO help VV . SENT The DT first JJ aid NN is VBZ a DT Boolean NP focus NN mask NN that WDT selects VVZ a DT subset NN of IN the DT processes NNS and CC then RB re NN applies VVZ the DT logical JJ algorithms NNS . SENT For IN properly RB chosen VVN subsets NNS , , this DT can MD turn VV a DT stack VV trace VV with IN many JJ multiframes NNS into IN a DT stack VV trace VV with IN synchronized VVN frames NNS . SENT A DT narrowed VVN focus NN can MD also RB look VV behind IN the DT scenes NNS of IN the DT twinning VVG mechanism NN described VVN in IN the DT next JJ paragraph NN . SENT The DT second JJ aid NN is VBZ to TO view VV a DT single JJ physical JJ process NN in IN isolation NN , , effectively RB turning VVG off RP the DT parallel JJ debugging VVG algorithms NNS . SENT This DT technique NN is VBZ useful JJ for IN debugging VVG EXTRINSIC JJ HPF NP LOCAL JJ and CC EXTRINSIC JJ HPF NP SERIAL NN procedures NNS . SENT The DT ability NN to TO retrieve VV the DT physical JJ processes NNS from IN a DT logical JJ process NN is VBZ the DT major JJ item NN that WDT enables VVZ viewing VVG a DT process NN in IN isolation NN . SENT as RB mentioned VVN before RB , , physical JJ entities NNS are VBP first JJ class NN objects NNS . SENT Twinning VVG DIGITAL JJ s PP HPF NP provides VVZ a DT feature NN called VVD twinning VVG in IN which WDT a DT scalar JJ procedure NN can MD call VV a DT parallel JJ HPF NP procedure NN . SENT This DT allows VVZ , , for IN example NN , , the DT main JJ program NN consisting VVG of IN a DT user NN interface NN and CC associated VVN graphics NNS to TO be VB written VVN in IN C NP and CC have VH Fortran NP HPF NP do VVP the DT numerical JJ computations NNS . SENT The DT feature NN is VBZ called VVN twinning VVG because IN each DT Fortran NP procedure NN is VBZ compiled VVN twice RB . SENT The DT scalar JJ twin NN is VBZ called VVN from IN scalar JJ code NN on IN a DT designated VVN process NN . SENT Its PP$ duties NNS include VVP instructing VVG the DT other JJ processes NNS to TO call VV the DT scalar JJ twin NN , , distributing VVG its PP$ scalar JJ arguments NNS according VVG to TO the DT HPF NP directives NNS , , calling VVG the DT HPF NP twin NN from IN all DT processes NNS , , distributing VVG the DT parallel JJ data NNS back RB onto IN the DT designated VVN process NN after IN the DT HPF NP twin NN returns NNS , , and CC finally RB returning VVG to TO its PP$ caller NN . SENT The DT HPF NP twin NN is VBZ called VVN on IN all DT processes NNS with IN distributed VVN data NNS and CC executes VVZ the DT user NN supplied VVD body NN of IN the DT procedure NN . SENT At IN the DT run VVN time NN level NN , , the DT program NN s PP entry NN point NN is VBZ normally RB called VVN on IN a DT designated VVN process NN process NN 0 CD , , and CC the DT other JJ processes NNS enter VVP a DT dispatch NN loop NN waiting VVG for IN instructions NNS . SENT Conceptually RB , , such PDT a DT program NN starts VVZ in IN scalar JJ mode NN and CC at IN some DT point NN transitions NNS into IN parallel JJ mode NN . SENT An DT HPF NP debugger NN should MD represent VV this DT transition NN . SENT Aardvark NN accomplishes VVZ this DT by IN having VHG knowledge NN of IN the DT HPF NP twinning VVG mechanism NN . SENT When WRB it PP notices VVZ physical JJ threads NNS entering VVG the DT dispatch NN loop NN , , Aardvark NN creates VVZ a DT scalar JJ logical JJ frame NN corresponding JJ to TO the DT physical JJ frame NN on IN process NN 0 CD . SENT It PP then RB processes VVZ procedure NN calls NNS on IN process NN 0 CD only RB , , creating VVG more JJR scalar JJ frames NNS , , until IN it PP notices NNS that IN the DT program NN transitions NNS from IN scalar NN to TO parallel VV . SENT This DT transition NN happens VVZ when WRB all DT processes NNS call VVP the DT same JJ scalar JJ twin JJ procedure NN . SENT process NN 0 CD does VVZ so RB as IN a DT result NN of IN normal JJ procedure NN calls NNS . SENT processes NNS other JJ than IN 0 CD do VVP so RB from IN their PP$ dispatch NN loops NNS . SENT At IN this DT point NN , , a DT logical JJ frame NN is VBZ constructed VVN that WDT will MD likely RB be VB synchronized VVN , , and CC the DT frame NN processing NN described VVD previously RB applies VVZ . SENT The DT result NN is VBZ the DT one NN desired VVD . SENT a DT scalar JJ program NN transitions NNS to TO a DT parallel JJ one CD . SENT DIGITAL JJ s PP HPF NP goes VVZ a DT step NN further RBR . SENT it PP allows VVZ EXTRINSIC JJ HPF NP SERIAL NN procedures NNS to TO call VV HPF NP code NN by IN means NNS of IN the DT twinning VVG mechanism NN . SENT When WRB an DT EXTRINSIC JJ HPF NP SERIAL NN procedure NN is VBZ called VVN , , processes VVZ other JJ than IN 0 CD call NN the DT dispatch NN loop NN . SENT When WRB the DT scalar JJ code NN on IN process NN 0 CD calls NNS the DT scalar JJ twin NN , , the DT other JJ processes NNS are VBP in IN the DT necessary JJ dispatch NN loop NN . SENT Aardvark NN tracks VVZ these DT calls NNS in IN the DT same JJ way NN as IN in IN the DT previous JJ paragraph NN , , noticing VVG that IN processes NNS other JJ than IN 0 CD have VHP called VVN the DT dispatch NN loop NN and CC eventually RB call VV a DT scalar JJ twin NN . SENT User NP Interface NP Implications NNS User NP interfaces NNS and CC other JJ clients NNS must MD be VB keenly RB aware JJ of IN the DT concept NN of IN logical JJ frames NNS and CC the DT different JJ types NNS of IN logical JJ frames NNS . SENT Depending VVG on IN the DT type NN of IN frame NN , , some DT operations NNS , , such JJ as IN obtaining VVG the DT function NN name NN or CC the DT line NN number NN , , may MD not RB be VB valid JJ . SENT Nevertheless RB , , a DT user NN interface NN can MD provide VV useful JJ information NN about IN the DT state NN of IN the DT program NN . SENT The DT program NN used VVN for IN the DT following VVG discussion NN has VHZ a DT serial JJ user NN interface NN written VVN in IN C NP and CC uses VVZ twinning VVG to TO call VV a DT parallel JJ HPF NP procedure NN named VVD HPF NP FILL VV IN IN DATA NNS see VVP Figure NP 3 CD . SENT The DT HPF NP procedure NN uses VVZ a DT function NN named VVN MANDEL NP VAL NP as IN a DT non JJ data NNS parallel JJ computational JJ kernel NN . SENT The DT program NN was VBD run VVN on IN five CD processes NNS . SENT Twinning VVG is VBZ a DT DIGITAL JJ extension NN . SENT Most JJS HPF NP programs NNS are VBP written VVN entirely RB in IN HPF NP . SENT This DT example NN , , which WDT uses VVZ twinning VVG , , was VBD chosen VVN to TO demonstrate VV the DT broader JJR problem NN . SENT subroutine NN hpf NNS fill VVP in IN data NN target NN , , w NN , , h NN , , ccr NP , , cci NP , , cstep NN , , nmin NP , , nmax NN integer NN , , intent NN in IN . SENT . SENT w NN , , h NN byte NN , , intent JJ out RP . SENT . SENT target NN w NN , , h NN real JJ 8 CD , , intent NN in IN . SENT . SENT ccr NP , , cci NP , , cstep NN integer NN , , intent NN in IN . SENT . SENT nmin NN , , nmax NN . SENT hpf NNS distribute VVP target NN , , cyclic JJ integer NN . SENT . SENT cx NN , , cy NP cx NP w NN 2 CD cy NP h NN 2 CD forall NN ix JJ 1 CD . SENT w NN , , iy NP 1 CD . SENT h NN target NN ix NN , , iy NP mandel NP val NP CMPLX NP ccr NN ix NN cx NN cstep NN , , cci NP iy NP cx NN cstep NN , , KIND NN KIND NN 0 CD . SENT 0 CD D NP 0 CD , , nmin NP , , nmax NN contains VVZ pure JJ byte NN function NN mandel NP val NP x SYM , , nmin NP , , nmax NN complex JJ KIND NN KIND NN 0 CD . SENT 0 CD D NP 0 CD , , intent NN in IN . SENT . SENT x SYM integer NN , , intent NN in IN . SENT . SENT nmin NN , , nmax NN integer NN . SENT . SENT n NN real JJ kind NN KIND NN 0 CD . SENT 0 CD D NP 0 CD . SENT . SENT xorgr NP , , xorgi NP , , xr NP , , xi NN , , xr NP 2 CD , , xi NN 2 CD , , rad NN 2 CD logical JJ . SENT . SENT keepgoing JJ n NN 1 CD xorgr NP REAL NP x SYM xorgi NP AIMAG NP x SYM xr NN xorgr NN xi NN xorgi NNS do VVP n NN n NN 1 CD xr NN 2 CD xr NN xr NN xi NN 2 CD xi NN xi NN xi NN 2 CD xr NN xi NN xorgi NNS keepgoing VVG n NN nmax NN rad NN 2 CD xr NN 2 CD xi NN 2 CD xr NN xr NN 2 CD xi NN 2 CD xorgr NN if IN keepgoing NN . SENT AND CC . SENT rad NN 2 CD 4 CD . SENT 0 CD cycle NN exit NN end NN do VVP if IN n NN nmax NN then RB mandel NP val NP nmax NN nmin NN else RB mandel NP val NP MOD JJ n NN , , nmax NN nmin NN end NN if IN end NN function NN mandel NP val NP end NN subroutine NN hpf NNS fill VVP in IN data NN Figure NP 3 CD HPF NP FILL NN IN IN DATA NN Procedure NN Source NN Code NP for IN Figures NNS 4 CD and CC 5 CD Figure NN 4 CD shows NNS the DT program NN interrupted VVN during IN computation NN . SENT Line NN 2 CD of IN the DT figure NN contains VVZ a DT single JJ function NN name NN , , MANDEL NP VAL NP . SENT Line NN 3 CD contains VVZ the DT function VVP s PP source NN file NN name NN but CC lists VVZ five CD line NN numbers NNS , , implying VVG that IN this DT is VBZ an DT unsynchronized JJ frame NN . SENT In IN fact NN , , the DT user NN interface NN discovered VVD that DT Aardvark NN created VVD an DT unsynchronized JJ logical JJ frame NN . SENT Instead RB of IN trying VVG to TO get VV a DT single JJ line NN number NN , , the DT user NN interface NN retrieved VVD the DT set NN of IN line NN numbers NNS and CC presented VVD them PP . SENT In IN lines NNS 4 CD through IN 10 CD , , the DT user NN interface NN also RB presented VVD the DT range NN of IN source NN lines NNS encompassing VVG the DT lines NNS of IN all PDT the DT component NN processes VVZ . SENT This DT user NN interface NN s PP up RB command VVP line NN 21 CD navigates VVZ to TO the DT calling VVG frame NN . SENT In IN this DT example NN , , the DT frame NN is VBZ synchronized VVN , , causing VVG the DT user NN interface NN to TO present VV the DT function VVP s PP source NN file NN and CC single JJ line NN number NN line NN 26 CD , , followed VVN by IN the DT single JJ source NN file NN line NN line NN 27 CD . SENT 1 CD Thread NN is VBZ interrupted VVN . SENT 2 CD 0 CD . SENT MANDEL NP VAL NP X NP differing VVG COMPLEX JJ KIND NN 8 CD values NNS , , NMIN NP 255 CD , , NMAX NP 510 CD 3 CD at IN mb NP . SENT hpf NP . SENT f SYM 90 CD . SENT 45 CD , , 44 CD , , 45 CD , , 40 CD , , 39 CD 4 CD 39 CD xr NN 2 CD xr NN xr NN 5 CD 40 CD xi NN 2 CD xi NN xi NN 6 CD 41 CD xi NN 2 CD xr NN xi NN xorgi NP 7 CD 42 CD keepgoing JJ n NN nmax NN 8 CD 43 CD rad NN 2 CD xr NN 2 CD xi NN 2 LS 9 CD 44 CD xr NN xr NN 2 CD xi NN 2 CD xorgr NN 10 CD 45 CD if IN keepgoing NN . SENT AND CC . SENT rad NN 2 CD 4 CD . SENT 0 CD cycle NN 11 CD 12 CD debugger NN print NN x SYM 13 CD 1 CD DIFFERING VVG VALUES NNS 14 CD 0 CD . SENT 0 CD . SENT 66200000000000003 CD , , 0 CD . SENT 114 CD 15 CD 1 CD . SENT 0 CD . SENT 59599999999999997 CD , , 0 CD . SENT 113 CD 16 CD 2 CD . SENT 0 CD . SENT 65300000000000002 CD , , 0 CD . SENT 112 CD 17 CD 3 CD . SENT 0 CD . SENT 93799999999999994 CD , , 0 CD . SENT 10600000000000001 CD 18 CD 4 CD . SENT 0 CD . SENT 56600000000000006 CD , , 0 CD . SENT 11 CD 19 JJ 20 CD 21 CD debugger NN up IN 22 CD 1 CD . SENT hpf NP hpf NP fill VV in IN data NNS TARGET VVP non JJ atomic JJ INTEGER NN KIND NN 1 CD , , DIMENSION NN 1 CD . SENT 400 CD , , 1 CD . SENT 400 CD , , 23 CD W NP 400 CD , , H NP 400 CD , , 24 CD CCR NP 0 CD . SENT 76000000000000001 CD , , CCI NP 0 CD . SENT 02 CD , , CSTEP NP 0 CD . SENT 001 CD , , 25 CD NMIN NP 255 CD , , NMAX NP 510 CD 26 CD at IN mb NP . SENT hpf NP . SENT f SYM 90 CD . SENT 14 CD 27 CD 14 CD forall NN ix JJ 1 CD . SENT w NN , , iy NP 1 CD . SENT h NN 28 CD 29 CD debugger NN info NN address NN target NN 30 CD locative NN to TO hpf NP section NN 5 CD peers NNS of IN type NN INTEGER NN KIND NN 1 CD , , DIMENSION NN 1 CD . SENT 400 CD , , 1 CD . SENT 400 CD 31 CD type NN INTEGER NN KIND NN 1 CD , , DIMENSION NN 1 CD . SENT 400 CD , , 1 CD . SENT 400 CD 32 CD phys NNS count VVP 5 CD 33 CD addresses NNS 34 CD 0 CD . SENT 0 CD x SYM 11 CD fff NN 71 CD f SYM 0 CD 35 CD 1 CD . SENT 0 CD x SYM 11 CD fff NN 7000 CD 36 CD 2 CD . SENT 0 CD x SYM 11 CD fff NN 7000 CD 37 CD 3 CD . SENT 0 CD x SYM 11 CD fff NN 7000 CD 38 CD 4 CD . SENT 0 CD x SYM 11 CD fff NN 7000 CD 39 CD arank NN 2 CD 40 CD trank NP 2 CD 41 CD diminfos NNS dlower NN dupper NN plower NN pupper NN . SENT . SENT . SENT dist NP k NN 42 CD 0 CD 1 CD 400 JJ 1 CD 400 CD . SENT . SENT . SENT collap RB 43 CD 1 CD 1 CD 400 JJ 1 CD 80 CD . SENT . SENT . SENT cyclic JJ 44 CD 45 CD debugger NN info NN address NN target NN 100 CD , , 100 CD 46 CD locative NN in IN peer NN in IN peer NN 4 CD . SENT . SENT . SENT 47 CD type NN INTEGER NN KIND NN 1 CD 48 CD peernum NN 4 CD 49 CD locative JJ locative NN to TO memory NN at IN dmem NP address NN 0 CD x SYM 11 CD fff NN 8 CD e NN 13 CD of IN type NN INTEGER NN KIND NN 1 CD Figure NN 4 CD Program NN Interrupted VVN during IN Computation NN Figure NN 5 CD shows NNS a DT summary NN of IN the DT program NN s PP call VVP stack VV when WRB it PP was VBD interrupted VVN during IN computation NN . SENT The DT summary NN is VBZ a DT mix NN of IN unsynchronized JJ , , synchronized VVN , , and CC scalar JJ frames NNS . SENT Frame NN 0 CD line NN 2 CD is VBZ unsynchronized JJ , , and CC the DT various JJ line NN numbers NNS are VBP presented VVN . SENT Its PP$ caller NN , , frame NN 1 CD line NN 3 CD , , is VBZ synchronized VVN with IN a DT single JJ line NN number NN . SENT All PDT this DT is VBZ consistent JJ with IN the DT previous JJ discussion NN . SENT Frame NN 1 CD is VBZ the DT HPF NP twin NN of IN the DT scalar JJ twin NN in IN frame NN 2 CD . SENT The DT scalar JJ twin NN of IN frame NN 2 CD is VBZ expected VVN to TO be VB called VVN by IN scalar JJ code NN , , confirmed VVN by IN frames NNS 3 CD and CC 4 CD . SENT Frame NN 5 CD is VBZ part NN of IN the DT twinning VVG mechanism NN . SENT process NN 0 CD is VBZ at IN line NN 499 CD , , while IN the DT other JJ processors NNS are VBP all RB at IN line NN 506 CD . SENT 1 CD debugger NN where WRB 2 CD 0 CD unsync JJ MANDEL NP VAL NP at IN mb NP . SENT hpf NP . SENT f SYM 90 CD . SENT 45 CD , , 44 CD , , 45 CD , , 40 CD , , 39 CD 3 CD 1 CD synchr NP hpf NP hpf NP fill VV in IN data NNS at IN mb NP . SENT hpf NP . SENT f SYM 90 CD . SENT 14 CD 4 CD 2 CD synchr NN hpf NNS fill VVP in IN data NNS at IN mb NP . SENT hpf NP . SENT f SYM 90 VVN . SENT 1 LS 5 CD 3 CD scalar JJ mb NN fill NN in IN data NNS at IN mb NP . SENT hpf NP . SENT c SYM . SENT 45 CD 6 CD 4 CD scalar NN main JJ at IN mb NP . SENT c SYM . SENT 421 CD 7 CD 5 CD unsync JJ hpf NNS twinning VVG main JJ usurper NN at IN . SENT . SENT . SENT libhpf NP hpf NP twin NN . SENT c LS . SENT 499 CD , , 506 CD , , 506 CD , , 506 CD , , 506 CD 8 CD 6 CD synchr NN start NN at IN . SENT . SENT . SENT alpha NN crt NN 0 CD . SENT s PP . SENT 361 CD 9 CD debugger NN focus NN 1 CD 4 CD 10 CD debugger NN where WRB 11 CD 0 CD unsync JJ MANDEL NP VAL NP at IN mb NP . SENT hpf NP . SENT f SYM 90 CD . SENT none NN , , 44 CD , , 45 CD , , 40 CD , , 39 CD 12 CD 1 CD synchr NP hpf NP hpf NP fill VV in IN data NNS at IN mb NP . SENT hpf NP . SENT f SYM 90 CD . SENT 14 CD 13 CD 2 CD synchr NN hpf NNS fill VVP in IN data NNS at IN mb NP . SENT hpf NP . SENT f SYM 90 VVN . SENT 1 LS 14 CD 3 CD synchr NP hpf NP non JJ peer NN 0 CD to TO dispatch VV loop NN at IN . SENT . SENT . SENT libhpf NP hpf NP twin NN . SENT c LS . SENT 575 CD 15 CD 4 CD synchr NP hpf NP twinning VVG main JJ usurper NN at IN . SENT . SENT . SENT libhpf NP hpf NP twin NN . SENT c LS . SENT 506 CD 16 CD 5 CD synchr NN start NN at IN . SENT . SENT . SENT alpha NN crt NN 0 CD . SENT s PP . SENT 361 CD Figure NN 5 CD Control NP Flow NP of IN a DT Twinned VVN Program NN Interrupted VVN during IN Computation NN Narrowing VVG the DT focus NN to TO exclude VV process NN 0 CD shows NNS a DT different JJ call NN stack VV summary NN lines NNS 9 CD through IN 16 CD of IN Figure NP 5 CD . SENT The DT new JJ frame NN 0 CD line NN 11 CD continues VVZ to TO be VB unsynchronized JJ , , but CC all PDT the DT other JJ frames NNS are VBP synchronized VVN . SENT The DT twinning VVG dispatch NN loop NN line NN 14 CD replaces VVZ the DT scalar JJ frames NNS of IN the DT global JJ focus NN lines NNS 5 CD and CC 6 CD . SENT This DT replacement NN causes VVZ the DT new JJ call NN stack VV , , corresponding JJ more JJR closely RB to TO the DT physical JJ threads NNS , , to TO have VH fewer JJR frames NNS than IN the DT global JJ call NN stack VV . SENT Interrupting VVG the DT program NN while IN idle JJ within IN the DT user NN interface NN shows VVZ more RBR about IN twinning VVG and CC also RB shows VVZ a DT multiframe NN see VVP Figure NP 6 CD . SENT Most JJS of IN the DT frames NNS are VBP scalar JJ except IN for IN the DT twinning VVG mechanism NN frame NN 7 CD , , line NN 9 CD and CC the DT initial JJ run NN time NN frame NN frame NN 8 CD , , line NN 10 CD . SENT Narrowing VVG the DT focus NN to TO exclude VV process NN 0 CD shows VVZ the DT twinning VVG mechanism NN while IN waiting VVG . SENT The DT twinning VVG mechanism NN at IN frames NNS 5 CD and CC 6 CD lines NNS 23 CD and CC 24 CD is VBZ similar JJ to TO the DT mechanism NN at IN frames NNS 3 CD and CC 4 CD lines NNS 14 CD and CC 15 CD of IN Figure NP 5 CD . SENT In IN Figure NP 6 CD , , they PP do VVP not RB call VV a DT scalar JJ twin NN but CC rather RB call VV the DT messaging VVG library NN to TO receive VV instructions NNS from IN process NN 0 CD . SENT The DT messaging VVG library NN , , however RB , , is VBZ often RB not RB synchronized VVN among IN the DT peers NNS , , and CC frame VV 2 CD line NN 15 CD shows NNS a DT multiframe NN . SENT This DT user NN interface NN shows VVZ a DT multiframe NN as IN a DT collection NN of IN one CD line NN summaries NNS of IN the DT physical JJ frames NNS lines NNS 16 CD through IN 20 CD . SENT 1 CD debugger NN where WRB 2 CD 0 CD scalar JJ poll NN at IN unknown JJ name NN . SENT 41 CD 3 CD 1 CD scalar NN disembodied JJ at IN unknown NN . SENT 459 CD 4 CD 2 CD scalar JJ XRead NN at IN unknown JJ name NN . SENT 1110 CD 5 CD 3 CD scalar JJ XReadEvents NNS at IN unknown JJ name NN . SENT 950 CD 6 CD 4 CD scalar JJ XNextEvent NN at IN unknown JJ name NN . SENT 37 CD 7 CD 5 CD scalar JJ HandleXInput NN at IN mb NP . SENT c SYM . SENT 58 CD 8 CD 6 CD scalar NN main JJ at IN mb NP . SENT c SYM . SENT 452 CD 9 CD 7 CD unsync JJ hpf NNS twinning VVG main JJ usurper NN at IN . SENT . SENT . SENT libhpf NP hpf NP twin NN . SENT c LS . SENT 499 CD , , 506 CD , , 506 CD , , 506 CD , , 506 CD 10 CD 8 CD synchr NN start NN at IN . SENT . SENT . SENT alpha NN crt NN 0 CD . SENT s PP . SENT 361 CD 11 CD debugger NN focus NN 1 CD 4 CD 12 CD debugger NN where WRB 13 CD 0 CD unsync JJ select JJ at IN unknown JJ name NN . SENT none NN , , 41 CD , , none NN , , 41 CD , , 41 CD 14 CD 1 CD unsync JJ TCP NN MsgRead NN at IN . SENT . SENT . SENT libhpf NP msgtcp NN . SENT c LS . SENT none NN , , 1057 CD , , none NN , , 1057 CD , , 1057 CD 15 CD 2 CD multi NNS 16 CD none NN 17 CD TCP NN RecvAvail NN at IN . SENT . SENT . SENT libhpf NP msgtcp NN . SENT c LS . SENT 1400 CD 18 CD swtch NN pri NN at IN unknown JJ name NN . SENT 118 CD 19 CD TCP NN RecvAvail NN at IN . SENT . SENT . SENT libhpf NP msgtcp NN . SENT c LS . SENT 1400 CD 20 CD TCP NN RecvAvail NN at IN . SENT . SENT . SENT libhpf NP msgtcp NN . SENT c LS . SENT 1400 CD 21 CD 3 CD unsync JJ hpf NP Recv NP at IN . SENT . SENT . SENT libhpf NP msgmsg NN . SENT c LS . SENT none NN , , 434 CD , , 488 CD , , 434 CD , , 434 CD 22 CD 4 CD synchr NP hpf NP RecvDir NP at IN . SENT . SENT . SENT libhpf NP msgmsg NN . SENT c LS . SENT 509 CD 23 CD 5 CD synchr NP hpf NP non JJ peer NN 0 CD to TO dispatch VV loop NN at IN . SENT . SENT . SENT libhpf NP hpf NP twin NN . SENT c LS . SENT 563 CD 24 CD 6 CD synchr NP hpf NP twinning VVG main JJ usurper NN at IN . SENT . SENT . SENT libhpf NP hpf NP twin NN . SENT c LS . SENT 506 CD 25 CD 7 CD synchr NN start NN at IN . SENT . SENT . SENT alpha NN crt NN 0 CD . SENT s PP . SENT 361 CD Figure NN 6 CD Control NP Flow NP of IN a DT Twinned VVN Program NN Interrupted VVN While IN Idle JJ in IN Scalar JJ Mode NP Examining VVG HPF NP Data NP Examining VVG data NN generally RB involves VVZ determining VVG where WRB the DT data NN is VBZ stored VVN , , fetching VVG the DT data NNS , , and CC then RB presenting VVG it PP . SENT HPF NP presents VVZ difficulties NNS in IN all DT three CD areas NNS . SENT Determining VVG where WRB data NN is VBZ stored VVN requires VVZ rich JJ and CC flexible JJ data NNS location NN representations NNS and CC associated VVN operations NNS . SENT Fetching VVG small JJ amounts NNS of IN data NNS can MD be VB done VVN naively RB , , one CD element NN at IN a DT time NN , , but CC for IN large JJ amounts NNS of IN data NNS , , e NN . SENT g NN . SENT , , data NNS used VVN for IN visualization NN , , faster JJR methods NNS are VBP needed VVN . SENT Displaying VVG data NNS can MD usually RB use VV the DT techniques NNS inherited VVN from IN the DT underlying JJ Fortran NP 90 CD support NN , , but CC some DT mechanism NN and CC corresponding JJ user NN interface NN handling NN is VBZ needed VVN when WRB replicated VVN data NNS has VHZ different JJ values NNS . SENT Data NP Location NP Representations NNS Representing VVG where WRB data NN is VBZ stored VVN is VBZ relatively RB easy JJ to TO do VV in IN languages NNS such JJ as IN C NP and CC Fortran NP 77 CD . SENT the DT data NN is VBZ in IN a DT register NN or CC in IN a DT contiguous JJ block NN of IN memory NN . SENT Fortran NP 90 CD introduced VVD assumed VVN shape NN and CC deferred JJ shape NN arrays NNS , , 13 CD where WRB successive JJ array NN elements NNS are VBP not RB necessarily RB adjacent JJ in IN memory NN . SENT HPF NP allows VVZ the DT array NN to TO be VB distributed VVN so RB that IN successive JJ array NN elements NNS are VBP not RB necessarily RB stored VVN in IN a DT single JJ process NN or CC address NN space NN . SENT These DT lead NN to TO data NNS that WDT can MD be VB stored VVN discontiguously RB in IN memory NN as IN well RB as RB in IN different JJ memories NNS . SENT Fortran NP 90 CD also RB introduced VVN array NN sections NNS , , vector NN valued VVN subscripts NNS , , and CC field NN of IN array NN operations NNS , , 14 CD which WDT further VV complicate VV the DT notion NN of IN where WRB data NN is VBZ stored VVN . SENT Although IN evaluating VVG an DT expression NN involving VVG an DT array NN can MD be VB accomplished VVN by IN reading VVG the DT entire JJ array NN and CC performing VVG the DT operations NNS in IN the DT debugger NN , , this DT approach NN is VBZ inefficient JJ , , especially RB for IN a DT result NN that WDT is VBZ sparse JJ compared VVN to TO the DT entire JJ array NN . SENT A DT standard JJ technique NN is VBZ to TO perform VV address NN arithmetic NN and CC fetch VV only RB the DT actual JJ data NN result NN at IN the DT end NN of IN the DT operation NN . SENT The DT usual JJ notion NN of IN an DT address NN , , however RB , , is VBZ that IN it PP describes VVZ the DT start NN of IN a DT contiguous JJ block NN of IN memory NN . SENT Richer JJR data NN location NN representations NNS are VBP necessary JJ . SENT These DT representations NNS can MD include VV registers NNS and CC contiguous JJ memory NN , , but CC they PP also RB need VVP to TO include VV discontiguous JJ memory NN and CC data NNS distributed VVN among IN multiple JJ processes NNS . SENT The DT representations NNS should MD also RB include VV the DT results NNS of IN expressions NNS involving VVG array NN sections NNS , , vector NN valued VVN subscripts NNS , , and CC field NN of IN array NN operations NNS , , thereby RB extending VVG address NN arithmetic NN to TO data NN location NN arithmetic NN . SENT Aardvark NN defines VVZ a DT locative JJ base NN class NN that WDT has VHZ a DT virtual JJ method NN to TO fetch VV the DT data NNS . SENT A DT variety NN of IN derived VVN classes NNS implement VV the DT data NN location NN representations NNS needed VVD . SENT DIGITAL JJ s PP Fortran NP 90 CD implements VVZ assumed VVN shape NN and CC deferred JJ shape NN arrays NNS using VVG descriptors NNS that WDT contain VVP run VV time NN information NN about IN the DT memory NN address NN of IN the DT first JJ element NN , , the DT bounds NNS , , and CC per IN dimension NN inter VV element NN spacing NN . SENT 15 CD Aardvark NN models NNS these DT types NNS of IN arrays NNS almost RB directly RB with IN a DT derivation NN of IN the DT locative JJ class NN that WDT holds VVZ the DT same JJ information NN as IN the DT descriptor NN . SENT Performing VVG expression NN operations NNS is VBZ relatively RB easy JJ . SENT An DT array NN section NN expression NN adjusts VVZ the DT bounds NNS and CC the DT inter VV element NN spacing NN . SENT A DT field NN of IN array NN operation NN offsets NNS the DT address NN to TO point VV to TO the DT component NN field NN and CC changes VVZ the DT element NN type NN to TO that DT of IN the DT field NN . SENT A DT vector NN valued VVN subscript JJ expression NN requires VVZ additional JJ support NN . SENT the DT representation NN for IN each DT dimension NN can MD be VB a DT vector NN of IN memory NN offsets NNS instead RB of IN bounds NNS and CC inter VV element NN spacing NN . SENT All DT arrays NNS in IN HPF NP are VBP qualified VVN , , explicitly RB or CC implicitly RB , , with IN ALIGN VV , , TEMPLATE NN , , and CC DISTRIBUTE VV directives NNS . SENT 16 CD DIGITAL's NP HPF NP uses VVZ a DT superset NN of IN the DT Fortran NP 90 CD descriptors NNS to TO encode VV this DT information NN . SENT Aardvark NN models NNS HPF NP arrays VVZ with IN another DT derivation NN of IN the DT locative JJ class NN that WDT holds VVZ information NN similar JJ to TO the DT HPF NP descriptors NNS . SENT The DT most RBS pronounced JJ difference NN is VBZ that DT Aardvark NN uses VVZ a DT single JJ locative NN to TO encode VV the DT descriptors NNS from IN the DT set NN of IN processes NNS . SENT Aardvark NN knows VVZ that IN the DT local JJ memory NN addresses NNS are VBP potentially RB different JJ on IN each DT process NN and CC maintains VVZ them PP as IN a DT vector NN , , but CC currently RB assumes VVZ that DT processor NN independent JJ information NN is VBZ the DT same JJ on IN all DT processes NNS and CC only RB encodes VVZ that DT information NN once RB . SENT Referring VVG again RB to TO Figure NP 4 CD , , line NN 22 CD shows NNS that IN the DT argument NN TARGET NN is VBZ an DT array NN , , and CC line NN 29 CD is VBZ a DT request NN for IN information NN about IN the DT location NN of IN its PP$ data NNS . SENT See VV also RB Figure NP 3 CD for IN the DT full JJ source NN , , including VVG the DT declaration NN and CC distribution NN of IN TARGET NN . SENT Figure NN 4 CD , , line NN 32 CD shows NNS that IN there EX are VBP five CD processes NNS , , and CC lines NNS 34 CD through IN 38 CD show NN the DT base NN address NN within IN each DT process NN . SENT The DT addresses NNS for IN processes NNS 1 CD through IN 4 CD happen VVP to TO be VB the DT same JJ , , but CC the DT address NN for IN process NN 0 CD is VBZ different JJ . SENT Lines NNS 39 CD and CC 40 CD show NN that IN the DT rank NN of IN the DT array NN arank NN and CC the DT rank NN of IN the DT template NN trank NP are VBP both DT 2 CD . SENT Lines NNS 42 CD and CC 43 CD show NN the DT dimension NN information NN for IN the DT array NN . SENT The DT declared VVN bounds NNS are VBP 1 CD . SENT 400 CD , , 1 CD . SENT 400 CD , , but CC the DT local JJ physical JJ bounds NNS are VBP 1 CD . SENT 400 CD , , 1 CD . SENT 80 CD and CC the DT distribution NN is VBZ , , CYCLIC JJ . SENT This DT is VBZ all RB accurate JJ . SENT distributing VVG the DT second JJ dimension NN on IN five CD processes NNS causes VVZ the DT local JJ physical JJ size NN for IN that DT dimension NN 80 CD to TO be VB one CD fifth NN the DT declared VVN bound JJ 400 CD . SENT Performing VVG expression NN operations NNS on IN HPF NP based VVN locatives NNS is VBZ more RBR involved VVN than IN for IN Fortran NP 90 CD . SENT Processing VVG a DT scalar JJ subscript NN not RB only JJ offsets NNS the DT base NN memory NN address NN but CC also RB restricts VVZ the DT set NN of IN processors NNS determined VVN by IN the DT dimension NN s PP distribution NN information NN . SENT Processing VVG a DT subscript JJ triplet NN , , e NN . SENT g NN . SENT , , from IN . SENT to TO . SENT stride NN , , involves VVZ adjusting VVG the DT declared VVN bounds NNS and CC the DT alignment NN . SENT it PP does VVZ not RB adjust VV the DT template NN or CC the DT physical JJ layout NN . SENT As RB in IN Fortran NP 90 CD , , processing VVG a DT vector NN valued VVN subscript JJ in IN HPF NP requires VVZ the DT locative NN to TO represent VV the DT effect NN of IN the DT vector NN . SENT For IN HPF NP , , the DT representation NN is VBZ pairs NNS of IN memory NN offsets NNS and CC processor NN set NN restrictions NNS . SENT Processing VVG a DT field NN of IN array NN operation NN adjusts VVZ the DT element NN type NN and CC offsets NNS each DT memory NN address NN . SENT When WRB selecting VVG a DT single JJ array NN element NN by IN providing VVG scalar JJ subscripts NNS , , another DT type NN of IN locative NN is VBZ useful JJ . SENT This DT locative NN describes VVZ on IN which WDT process NN the DT data NN is VBZ stored VVN and CC a DT locative JJ relative NN to TO that DT selected JJ process NN . SENT For IN example NN , , line NN 45 CD of IN Figure NN 4 CD requests NNS the DT location NN information NN of IN a DT single JJ array NN element NN . SENT The DT result NN shows VVZ that IN it PP is VBZ on IN process NN 4 CD at IN the DT memory NN address NN indicated VVD by IN the DT contained JJ locative NN . SENT Fetching VVG HPF NP Data NP As IN just RB mentioned VVN , , locatives NNS provide VVP a DT method NN to TO fetch VV the DT data NNS described VVN by IN the DT locative NN . SENT For IN a DT locative NN that WDT describes VVZ a DT single JJ distributed VVN array NN element NN e NN . SENT g NN . SENT , , Figure NP 4 CD , , lines NNS 45 CD through IN 49 CD , , the DT method NN extracts VVZ the DT appropriate JJ physical JJ thread NN from IN the DT logical JJ thread NN and CC uses VVZ the DT contained VVN locative NN to TO fetch VV the DT data NNS relative JJ to TO the DT extracted VVN physical JJ thread NN . SENT For IN a DT locative NN that WDT describes VVZ an DT HPF NP array NN , , Aardvark NN currently RB iterates VVZ over IN the DT valid JJ subscript JJ space NN , , determines VVZ the DT physical JJ process NN number NN and CC memory NN offset VVN for IN each DT element NN , , and CC fetches VVZ the DT element NN from IN the DT selected JJ physical JJ process NN . SENT For IN small JJ numbers NNS of IN elements NNS , , on IN the DT order NN of IN a DT few JJ dozen NN , , this DT technique NN has VHZ acceptable JJ performance NN . SENT For IN large JJ numbers NNS of IN elements NNS , , e NN . SENT g NN . SENT , , for IN visualization NN or CC reduction NN operations NNS , , the DT cumulative JJ processing NN and CC communication NN delay NN to TO retrieve VV each DT individual JJ element NN is VBZ unacceptable JJ . SENT This DT performance NN issue NN also RB exists VVZ for IN locatives NNS that WDT describe VVP discontiguous JJ Fortran NP 90 CD arrays NNS . SENT The DT threshold NN is VBZ higher JJR because IN there EX is VBZ no DT computation NN to TO determine VV the DT process NN for IN an DT element NN , , and CC the DT process NN is VBZ usually RB local JJ rather RB than IN remote JJ , , eliminating VVG communication NN delays NNS . SENT The DT primary JJ bottleneck NN is VBZ issuing VVG many JJ small JJ data NN retrieval NN requests NNS to TO each DT remote JJ process NN . SENT This DT involves VVZ many JJ communication NN delays NNS and CC many JJ delays NNS related VVN to TO retrieving VVG each DT element NN . SENT What WP is VBZ needed VVN is VBZ to TO issue VV a DT smaller JJR number NN of IN larger JJR requests NNS . SENT The DT smaller JJR number NN reduces VVZ the DT number NN of IN communication NN transactions NNS and CC associated VVN delays NNS . SENT Larger JJR requests NNS allow VVP analysis NN of IN a DT request NN to TO make VV more RBR efficient JJ use NN of IN the DT operating VVG system NN s PP mechanisms NNS to TO access VV process NN memory NN . SENT For IN example NN , , a DT sufficiently RB dense JJ request NN can MD read VV the DT encompassing VVG memory NN in IN a DT single JJ call NN to TO the DT operating VVG system NN and CC then RB extract VV the DT desired VVN elements NNS once IN the DT data NN is VBZ within IN the DT debugger NN . SENT Although IN not RB implemented VVN , , the DT best JJS solution NN , , in IN my PP$ opinion NN , , is VBZ to TO provide VV a DT read VVN multidimensional JJ memory NN section NN method NN on IN a DT process NN in IN addition NN to TO the DT common JJ read VVN contiguous JJ memory NN method NN . SENT If IN the DT process NN is VBZ remote JJ , , as IN it PP usually RB is VBZ with IN HPF NP , , the DT method NN would MD be VB forwarded VVN to TO a DT remote JJ debug VV server NN controlling VVG the DT remote JJ process NN . SENT The DT implementation NN of IN the DT method NN that WDT interacts VVZ with IN the DT operating NN system NN would MD know VV the DT trade NN offs NNS to TO determine VV how WRB to TO analyze VV the DT request NN for IN maximum JJ efficiency NN . SENT Converting VVG a DT locative NN describing VVG a DT Fortran NP 90 CD array NN section NN to TO a DT read VVN memory NN section NN method NN should MD be VB easy JJ . SENT they PP represent VVP nearly RB the DT same JJ thing NN . SENT For IN a DT locative NN that WDT describes VVZ a DT distributed VVN HPF NP array NN , , Aardvark NN would MD need VV to TO build VV physical JJ memory NN section NN descriptions NNS for IN each DT physical JJ process NN . SENT This DT can MD be VB done VVN by IN iterating VVG over IN the DT physical JJ processes NNS and CC building VVG the DT memory NN section NN for IN each DT process NN . SENT It PP is VBZ also RB possible JJ to TO build VV the DT memory NN sections NNS for IN all PDT the DT processes NNS during IN a DT single JJ pass NN through IN the DT locative NN , , but CC the DT performance NN gains NNS may MD not RB be VB large JJ enough RB to TO warrant VV the DT added JJ complexity NN . SENT Differing VVG Values NNS Using VVG HPF NP to TO distribute VV an DT array NN often RB partitions VVZ its PP$ elements NNS among IN the DT processes NNS . SENT Scalars NNS , , however RB , , are VBP generally RB replicated VVN and CC may MD be VB expected VVN to TO have VH the DT same JJ value NN in IN each DT process NN . SENT There EX are VBP cases NNS , , though RB , , where WRB seemingly RB replicated VVN scalars NNS may MD not RB have VH the DT same JJ value NN . SENT DO VVP loops NNS that WDT do VVP not RB require VV data NNS to TO be VB communicated VVN between IN processes NNS do VVP not RB have VH synchronization NN points NNS and CC can MD become VV out RP of IN phase NN , , resulting VVG in IN their PP$ indexes NNS and CC other JJ privatized JJ variables NNS having VHG different JJ values NNS . SENT Functions NNS called VVD within IN a DT FORALL NP construct VV often RB run VV independently RB of IN each DT other JJ , , causing VVG the DT arguments NNS and CC local JJ variables NNS in IN one CD process NN to TO be VB different JJ from IN those DT in IN another DT . SENT A DT debugger NN should MD be VB aware JJ that IN values NNS might MD differ VV and CC adjust VV the DT presentation NN of IN such JJ values NNS accordingly RB . SENT Aardvark NN s PP approach VVP is VBZ to TO define VV a DT new JJ kind NN of IN value NN object NN called VVD differing VVG values NNS to TO represent VV a DT value NN from IN a DT semantically RB single JJ source NN that WDT does VVZ not RB have VH the DT same JJ value NN from IN all PDT its PP$ actual JJ sources NNS . SENT A DT user NN interface NN can MD detect VV this DT kind NN of IN value NN and CC display VV it PP in IN different JJ ways NNS , , for IN example NN , , based VVN on IN context NN and CC or CC the DT size NN of IN the DT data NNS . SENT Referring VVG again RB to TO Figure NP 4 CD , , the DT program NN was VBD interrupted VVN while IN each DT process NN was VBD executing VVG the DT function NN MANDEL NP VAL NP called VVD within IN a DT FORALL NP . SENT Line NN 2 CD shows NNS that IN the DT argument NN X NN was VBD determined VVN to TO have VH differing VVG values NNS . SENT This DT user NN interface NN does VVZ not RB show VV all PDT the DT values NNS at IN this DT point NN . SENT a DT large JJ number NN of IN values NNS could MD distract VV the DT user NN from IN the DT current JJ objective NN of IN discovering VVG where WRB the DT process NN stopped VVD . SENT Instead RB , , it PP shows VVZ an DT indication NN that IN the DT values NNS are VBP different JJ along IN with IN the DT type NN of IN the DT variable NN . SENT Notice NN that IN the DT other JJ two CD arguments NNS , , NMIN NP and CC NMAX NP , , are VBP presented VVN as IN integers NNS . SENT they PP have VHP the DT same JJ value NN in IN all DT processes NNS . SENT Line NN 12 CD requests NNS to TO see VV the DT value NN of IN X NP . SENT Line NP 13 NP again RB shows VVZ that IN the DT values NNS are VBP different JJ , , and CC lines NNS 14 CD through IN 18 CD show NN the DT process NN number NN and CC the DT value NN from IN the DT process NN . SENT To TO build VV a DT differing VVG values NNS object VVP , , Aardvark NN reads VVZ the DT values NNS for IN a DT replicated VVN scalar NN from IN each DT process NN . SENT If IN all PDT the DT values NNS are VBP bit NN wise JJ equal JJ , , they PP are VBP considered VVN to TO be VB the DT same JJ and CC a DT standard JJ single JJ value NN object NN is VBZ returned VVN . SENT Otherwise RB , , a DT differing VVG values NNS object VVP is VBZ constructed VVN from IN the DT several JJ values NNS . SENT For IN numeric JJ data NNS , , this DT approach NN seems VVZ reasonable JJ . SENT If IN the DT value NN of IN a DT scalar JJ integer NN variable NN INTVAR NP is VBZ 4 CD on IN all PDT the DT processes NNS , , then RB 4 CD is VBZ a DT reasonable JJ single JJ value NN for IN INTVAR NP . SENT If IN the DT value NN of IN INTVAR NP is VBZ 4 CD on IN some DT processors NNS and CC 5 CD on IN others NNS , , no DT single JJ value NN is VBZ reasonable JJ . SENT For IN nonnumeric JJ data NNS and CC pointers NNS , , there EX is VBZ the DT possibility NN of IN false JJ positives NNS and CC false JJ negatives NNS . SENT The DT ideal NN for IN user NN defined VVN types NNS is VBZ to TO compare VV the DT fields NNS recursively RB . SENT Pointers NNS that WDT are VBP semantically RB the DT same JJ can MD point VV to TO targets NNS located VVN at IN different JJ memory NN addresses NNS for IN unrelated JJ reasons NNS , , leading VVG to TO different JJ memory NN address NN values NNS and CC therefore RB a DT false JJ positive NN . SENT To TO correctly RB dereference NN the DT pointers NNS , , though RB , , Aardvark NN needs VVZ the DT different JJ memory NN address NN values NNS . SENT In IN short JJ , , it PP is VBZ reasonable JJ to TO test VV numeric JJ data NNS and CC create VV a DT single JJ value NN object NN or CC a DT differing VVG values NNS object VVP , , and CC it PP appears VVZ reasonable JJ to TO do VV the DT same JJ for IN nonnumeric JJ data NNS , , despite IN the DT possibility NN of IN a DT technically RB false JJ kind NN of IN value NN object NN . SENT Currently RB , , differing VVG values NNS do VVP not RB participate VV in IN arithmetic NN . SENT That DT is VBZ , , the DT expression NN INTVAR NN . SENT LT NP . SENT 5 CD is VBZ valid JJ if IN INTVAR NP is VBZ a DT single JJ value NN but CC causes VVZ an DT error NN to TO be VB signaled VVN if IN INTVAR NP is VBZ a DT differing VVG value NN . SENT Many JJ cases NNS could MD be VB made VVN to TO work VV , , but CC some DT cases NNS defy VV resolution NN . SENT In IN the DT INTVAR NP . SENT LT NP . SENT 5 CD case NN , , if IN all DT values NNS of IN INTVAR NP are VBP less JJR than IN 5 CD or CC all DT are VBP greater JJR than IN or CC equal VV to TO 5 CD , , then RB it PP is VBZ reasonable JJ to TO collapse VV the DT result NN into IN a DT single JJ value NN , , . SENT TRUE JJ . SENT or JJ . SENT FALSE JJ . SENT , , respectively RB . SENT If IN some DT values NNS are VBP less JJR than IN 5 CD and CC some DT are VBP not RB , , it PP also RB seems VVZ reasonable JJ to TO create VV a DT differing VVG values NNS object NN that WDT holds VVZ the DT differing VVG results NNS . SENT What WP if IN INTVAR NP . SENT LT NP . SENT 5 CD is VBZ used VVN as IN the DT condition NN of IN a DT breakpoint NN and CC some DT values NNS of IN INTVAR NP are VBP less JJR than IN 5 CD and CC some DT are VBP not RB . SENT The DT breakpoint NN should MD probably RB cause VV the DT process NN and CC all PDT the DT physical JJ processes NNS to TO remain VV stopped VVN . SENT It PP is VBZ unclear JJ whether IN arithmetic NN on IN differing VVG values NNS would MD be VB useful JJ to TO users NNS or CC if IN it PP would MD lead VV to TO more JJR confusion NN than IN it PP would MD clear VV up RP . SENT Unmet JJ Challenges NNS HPF NP presents VVZ a DT variety NN of IN challenges NNS that IN Aardvark NN does VVZ not RB yet RB address VV . SENT Some DT of IN these DT challenges NNS are VBP not RB in IN common JJ practice NN , , giving VVG them PP low JJ priority NN . SENT Some DT are VBP recent JJ with IN HPF NP Version NP 2 CD . SENT 0 CD and CC are VBP being VBG used VVN with IN increasing VVG frequency NN . SENT Some DT of IN the DT challenges NNS , , for IN example NN , , a DT debugger NN initiated VVD call NN of IN an DT HPF NP procedure NN , , are VBP tedious JJ to TO address VV correctly RB . SENT Mapped VVN Scalars NNS It PP is VBZ possible JJ to TO distribute VV a DT scalar NN so RB that IN the DT scalar NN is VBZ not RB fully RB replicated VVN . SENT 17 CD The DT compiler NN would MD need VV to TO emit VV sufficient JJ debugging VVG information NN , , which WDT would MD probably RB be VB a DT virtual JJ array NN descriptor NN with IN an DT array NN rank NN of IN 0 CD and CC a DT nonzero NN template NN rank NN . SENT Aardvark NN would MD probably RB model VV it PP using VVG its PP$ existing JJ locative NN for IN HPF NP arrays NNS , , also RB with IN an DT array NN rank NN of IN 0 CD and CC appropriate JJ template NN information NN . SENT Replicated VVN Arrays NNS Unless IN otherwise RB specified JJ , , DIGITAL JJ s PP HPF NP compiler NN replicates VVZ arrays NNS . SENT It PP is VBZ possible JJ to TO replicate VV arrays NNS explicitly RB and CC to TO align VV arrays NNS and CC scalars NNS so RB that IN they PP are VBP partially RB replicated VVN . SENT Currently RB , , Aardvark NN does VVZ not RB detect VV a DT replicated VVN array NN , , despite IN the DT symbol NN table NN or CC run VV time NN descriptor NN indicating VVG that IN it PP is VBZ replicated VVN . SENT As IN a DT result NN , , Aardvark NN determines VVZ a DT single JJ process NN from IN which WDT to TO fetch VV each DT array NN element NN . SENT For IN fully RB replicated VVN arrays NNS , , Aardvark NN should MD read VV the DT array NN from IN each DT process NN and CC process VV them PP with IN the DT differing VVG values NNS algorithms NNS . SENT Correctly RB processing VVG arrays NNS that WDT are VBP partially RB replicated VVN is VBZ not RB as RB easy JJ as IN processing VVG unreplicated JJ or CC fully RB replicated VVN arrays NNS . SENT If IN the DT odd JJ columns NNS are VBP on IN processes NNS 0 CD and CC 1 CD , , while IN the DT even JJ columns NNS are VBP on IN processes NNS 2 CD and CC 3 CD , , no DT single JJ process NN contains VVZ the DT entire JJ array NN . SENT The DT differing VVG values NNS object VVP would MD need VV to TO be VB extended VVN to TO index NN the DT values NNS by IN a DT processor NN set VVD rather RB than IN a DT single JJ process NN . SENT Update VV of IN Distributed NP and CC Replicated VVN Objects NNS Aardvark NN currently RB supports VVZ limited JJ modification NN of IN data NNS . SENT It PP supports VVZ updating VVG a DT scalar JJ object NN scalar NN variable NN or CC single JJ array NN element NN with IN a DT scalar JJ value NN , , even RB if IN the DT object NN is VBZ distributed VVN or CC replicated VVN . SENT Even RB this DT can MD be VB incorrect JJ at IN times NNS . SENT Assigning VVG a DT scalar JJ value NN to TO a DT replicated VVN object NN sets VVZ each DT copy NN , , which WDT is VBZ undesirable JJ if IN the DT object NN has VHZ differing VVG values NNS . SENT Assigning VVG a DT value NN that WDT is VBZ a DT differing VVG values NNS object VVP is VBZ not RB supported VVN . SENT More RBR importantly RB and CC more RBR subtly RB , , Aardvark NN is VBZ not RB aware JJ of IN shadow NN or CC halo NN copies NNS of IN data NNS that WDT are VBP stored VVN in IN multiple JJ processes NNS , , so RB updating VVG a DT distributed VVN object NN updates NNS only RB the DT primary JJ location NN . SENT Distributed VVN Array NN Pointers NNS HPF NP Version NP 2 CD . SENT 0 CD allows VVZ array NN pointers NNS in IN user NN defined VVN types NNS to TO be VB distributed VVN and CC allows VVZ fully RB replicated VVN arrays NNS of IN such JJ types NNS . SENT For IN example NN , , in IN type NN utype NN integer NN , , pointer NN . SENT . SENT compptr NN . SENT . SENT hpf NNS distribute VVP compptr NN block NN end NN type NN type NN utype NN . SENT . SENT scalar NN , , array NN 20 CD the DT component NN field NN compptr NN is VBZ a DT distributed VVN array NN pointer NN . SENT Aardvark NN does VVZ not RB currently RB process VV the DT array NN descriptor NN s PP for IN scalar JJ compptr NN at IN the DT right JJ place NN and CC as IN a DT result NN does VVZ not RB recognize VV the DT expression NN as IN an DT array NN . SENT As IN mentioned VVN earlier RBR , , Aardvark NN reads VVZ a DT replicated VVN array NN element NN from IN a DT single JJ process NN . SENT To TO process VV array NN 1 CD compptr NN , , all PDT the DT descriptors NNS are VBP needed VVN , , e NN . SENT g NN . SENT , , for IN the DT base JJ memory NN addresses NNS in IN the DT physical JJ processes NNS . SENT The DT use NN of IN this DT relatively RB new JJ construct VV is VBZ growing VVG rapidly RB , , elevating VVG the DT importance NN of IN being VBG supported VVN by IN debuggers NNS . SENT Ensuring VVG a DT Consistent JJ View NN A DT program NN can MD have VH its PP$ physical JJ threads NNS stop VVP at IN the DT same JJ place NN but CC be VB in IN different JJ iterations NNS of IN a DT loop NN . SENT Aardvark NN mistakenly RB presents VVZ this DT state NN as RB synchronized VVN and CC presents VVZ data NNS as IN if IN it PP were VBD consistent JJ . SENT This DT is VBZ what WP is VBZ happening VVG in IN Figures NNS 4 CD and CC 5 CD . SENT hpf NP hpf NP fill VV in IN data NNS frame NN 1 CD is VBZ in IN different JJ iterations NNS of IN the DT FORALL NP . SENT With IN compiler NN assistance NN , , it PP is VBZ possible JJ to TO annotate VV each DT thread NN s PP location NN with IN iteration NN counts NNS in IN addition NN to TO traditional JJ line NN numbers NNS . SENT 18 RB The DT resulting VVG set NN of IN locations NNS can MD be VB compared VVN to TO a DT location NN in IN the DT conceptually RB serial JJ program NN to TO determine VV which WDT threads NNS have VHP already RB reached VVN and CC perhaps RB passed VVD the DT serial JJ location NN and CC which WDT have VHP not RB yet RB reached VVN it PP . SENT A DT debugger NN could MD automatically RB , , or CC under IN user NN control NN , , advance VV each DT thread NN to TO a DT consistent JJ serial JJ location NN . SENT For IN now RB , , Aardvark NN s PP differing VVG values NNS mechanism NN is VBZ the DT clue NN to TO the DT user NN that IN program NN state NN might MD not RB be VB consistent JJ . SENT Calling VVG an DT HPF NP Procedure NN Having VHG a DT debugger NN initiate VV a DT call NN to TO a DT Fortran NP 90 CD procedure NN is VBZ difficult JJ in IN the DT general JJ case NN . SENT One CD difficulty NN is VBZ that DT copy NN in IN copy NN out IN making VVG a DT temporary JJ copy NN of IN array NN arguments NNS and CC copying VVG the DT temporary JJ back NN to TO its PP$ origin NN after IN the DT call NN returns NNS may MD be VB necessary JJ . SENT HPF NP adds VVZ two CD more JJR difficulties NNS . SENT First RB , , the DT data NNS may MD need VV to TO be VB redistributed VVN , , which WDT amounts VVZ to TO a DT distributed VVN copy NN in IN copy NN out RP and CC entails VVZ a DT lot NN of IN tedious JJ but CC hopefully RB straightforward JJ bookkeeping NN . SENT Second RB , , an DT HPF NP thread NN s PP state VVP is VBZ much RB more RBR complex JJ than IN a DT collection NN of IN physical JJ thread NN states NNS . SENT When WRB a DT debugger NN initiates VVZ a DT uniprocessor NN procedure NN call NN , , it PP generally RB saves VVZ the DT registers NNS , , sets VVZ up RP the DT registers NNS and CC stack VV according VVG to TO the DT calling VVG convention NN , , lets VVZ the DT process NN run VVN until IN the DT call NN returns NNS , , extracts VVZ the DT result NN , , and CC finally RB restores VVZ the DT registers NNS . SENT The DT registers NNS are VBP generally RB the DT state NN that WDT is VBZ preserved VVN across IN a DT debugger NN initiated VVD procedure NN call NN . SENT For IN HPF NP , , and CC in IN general NN for IN other JJ paradigms NNS that WDT use VVP message NN passing VVG , , it PP may MD be VB necessary JJ to TO preserve VV the DT run VVN time NN state NN of IN the DT messaging VVG subsystem NN in IN each DT process NN . SENT This DT preservation NN probably RB amounts VVZ to TO making VVG uniprocessor NN calls VVZ to TO messaging VVG supplied VVN save VV restore VV entry NN points NNS , , allowing VVG the DT messaging VVG subsystem NN to TO define VV what WP its PP$ state NN is VBZ and CC how WRB it PP should MD be VB saved VVN and CC restored VVN . SENT Although IN logical JJ entities NNS would MD be VB used VVN to TO coordinate VV the DT physical JJ details NNS , , this DT is VBZ a DT lot NN of IN work NN and CC has VHZ not RB been VBN prototyped VVN . SENT Related NP Work NP DIGITAL JJ s PP representative JJ to TO the DT first JJ meeting NN of IN the DT HPF NP User NP Group NP reported VVD a DT general JJ lament NN among IN users NNS about IN the DT lack NN of IN debugger NN support NN . SENT 19 CD , , 20 CD Browsing NN the DT World NP Wide NP Web NP reveals VVZ little RB on IN the DT topic NN of IN HPF NP debugging VVG , , although IN some DT efforts NNS have VHP provided VVN various JJ degrees NNS of IN sophistication NN . SENT Multiple JJ Serial JJ Debuggers NP A DT simplistic JJ approach NN to TO debugging VVG support NN is VBZ to TO start VV a DT traditional JJ serial JJ debugger NN on IN each DT component NN process NN , , perhaps RB providing VVG a DT separate JJ window NN for IN each DT and CC providing VVG some DT command NN broadcast NN capability NN . SENT Although IN this DT approach NN provides VVZ basic JJ debugging VVG , , it PP does VVZ not RB address VV any DT of IN the DT interesting JJ challenges NNS of IN HPF NP debugging VVG . SENT Prism NN The DT Prism NN debugger NN versions NNS dating VVG from IN 1992 CD , , formerly RB from IN Thinking VVG Machines NP Corporation NP , , provides VVZ debugging VVG support NN for IN CM NP Fortran NP 21 CD , , 22 CD The DT run NN time NN model NN of IN CM NP Fortran NP is VBZ essentially RB single JJ instruction NN , , multiple JJ data NNS SIMD NP , , which WDT considerably RB simplifies VVZ managing VVG the DT program NN . SENT The DT program NN gets VVZ compiled VVN into IN an DT executable JJ that IN broadcasts NNS macroinstructions NNS to TO the DT parallel JJ machine NN , , even RB on IN the DT CM NP 5 CD synchronized VVN multiple JJ instruction NN , , multiple JJ data NNS MIMD JJ machine NN . SENT Prism NN primarily RB debugs VVZ the DT single JJ program NN doing VVG the DT broadcasting NN . SENT Therefore RB , , operations NNS such JJ as IN starting VVG , , stopping VVG , , and CC setting VVG breakpoints NNS can MD use VV the DT traditional JJ uniprocessor NN debugging VVG techniques NNS . SENT Prism NN is VBZ aware JJ of IN distributed VVN data NNS . SENT When WRB visualizing VVG a DT distributed VVN array NN , , however RB , , it PP presents VVZ each DT process NN s PP local JJ portion NN and CC conceptually RB augments VVZ the DT rank NN of IN the DT array NN to TO include VV a DT process NN axis NN . SENT For IN example NN , , a DT two CD dimensional JJ 400 CD 400 CD array NN distributed VVN , , CYCLIC JJ on IN five CD processes NNS is VBZ presented VVN as IN a DT 400 CD 80 CD 5 CD array NN . SENT For IN explicit JJ message NN sending VVG programs NNS , , Prism NN controls VVZ the DT target NN processes VVZ and CC provides VVZ a DT where WRB graph NN , , which WDT has VHZ some DT of IN the DT visual JJ cues NNS that IN Aardvark NN s PP logical JJ frames NNS provide VVP . SENT TotalView NN Recent JJ 1997 CD versions NNS of IN the DT TotalView NP debugger NN , , from IN Dolphin NP Interconnect NP Solutions NNS , , Inc NP . SENT , , provide VV some DT support NN for IN the DT HPF NP compiler NN from IN The DT Portland NP Group NP , , Inc NP . SENT 23 CD , , 24 CD TotalView NP provides VVZ process NN groups NNS , , which WDT are VBP treated VVN more RBR like IN sets NNS for IN set VVN wide JJ operations NNS than IN like IN a DT synthesis NN into IN a DT single JJ logical JJ entity NN . SENT As IN a DT result NN , , no DT unified JJ view NN of IN the DT call NN stacks NNS exists VVZ . SENT TotalView NP can MD dive VV into IN a DT distributed VVN HPF NP array NN and CC present VV it PP as IN a DT single JJ array NN in IN terms NNS of IN the DT original JJ source NN . SENT Distributed VVN data NNS is VBZ not RB currently RB integrated VVN into IN the DT expression NN system NN , , however RB , , so IN a DT conditional JJ breakpoint NN such JJ as IN A DT 3 CD , , 4 CD . SENT LT NP . SENT 5 CD does VVZ not RB work VV . SENT TotalView NP is VBZ being VBG actively RB developed VVN . SENT future JJ versions NNS will MD likely RB provide VV more RBR complete JJ support NN for IN HPF NP . SENT Applicability NN to TO Other JJ Areas NNS Many JJ of IN the DT techniques NNS that IN Aardvark NN incorporates VVZ can MD apply VV to TO other JJ areas NNS , , including VVG the DT single JJ program NN , , multiple JJ data NNS SPMD NP paradigm NN , , debugging VVG optimized VVN code NN , , and CC interpreted VVN languages NNS . SENT Single JJ Program NN , , Multiple JJ Data NP Logical JJ entities NNS can MD be VB used VVN to TO manage VV and CC examine VV programs NNS that WDT use VVP the DT SPMD NP paradigm NN . SENT This DT is VBZ true JJ for IN process NN level NN SPMD NP , , which WDT is VBZ commonly RB used VVN with IN explicit JJ message NN sending VVG such JJ as IN MPI NP , , 5 CD , , 6 CD and CC for IN thread NN level NN SPMD NP such JJ as IN directed VVN decomposition NN . SENT 25 CD 27 CD Aardvark NN s PP twinning VVG algorithms NNS can MD be VB used VVN in IN both DT cases NNS . SENT Process NN level NN SPMD NP is VBZ similar JJ to TO DIGITAL JJ s PP HPF NP . SENT the DT equivalent NN of IN twinning VVG requires VVZ a DT stylistic JJ way NN of IN coding VVG and CC declaring VVG a DT dispatch NN loop NN . SENT Thread NN level NN SPMD NP usually RB has VHZ a DT pool NN of IN threads NNS waiting VVG in IN a DT dispatch NN loop NN , , requiring VVG Aardvark NN to TO know VV some DT mechanics NNS of IN the DT run VVN time NN support NN . SENT The DT differing VVG values NNS mechanism NN can MD apply VV to TO data NNS in IN SPMD NP paradigms NNS . SENT DIGITAL JJ s PP recent JJ introduction NN of IN Thread NN Local NP Storage NP TLS NP , , 28 CD modeled VVD on IN the DT Thread NN Local JJ Storage NP facility NN of IN Microsoft NP Visual NP C NP 29 CD with IN similarities NNS to TO TASKCOMMON NP of IN Cray NP Fortran NP , , 30 CD provides VVZ another DT source NN of IN the DT same JJ variable NN having VHG potentially RB differing VVG values NNS in IN different JJ thread NN contexts NNS . SENT Debugging VVG Optimized VVN Code NP Aardvark NN s PP flexible JJ locative JJ subsystem NN and CC its PP$ awareness NN of IN nonsingular JJ values NNS i NP . SENT e SYM . SENT , , differing VVG values NNS can MD be VB the DT basis NN for IN split NN lifetime NN variables NNS . SENT In IN optimized VVN code NN , , a DT variable NN can MD have VH several JJ simultaneous JJ lifetimes NNS e NN . SENT g NN . SENT , , the DT result NN of IN loop NN unrolling VVG or CC no DT active JJ lifetime NN e NN . SENT g NN . SENT , , between IN a DT usage NN and CC the DT next JJ assignment NN . SENT New JJ derivations NNS of IN the DT locative JJ class NN can MD describe VV the DT multiple JJ homes NNS or CC the DT nonexistent JJ home NN of IN a DT variable NN . SENT Fetching VVG by IN means NNS of IN such PDT a DT locative NN creates VVZ new JJ kinds NNS of IN values NNS that WDT hold VV all PDT the DT values NNS or CC an DT indication NN that IN there EX is VBZ no DT value NN . SENT User NN interfaces NNS become VVP aware JJ of IN these DT new JJ kinds NNS of IN values NNS in IN ways NNS similar JJ to TO their PP$ awareness NN of IN differing VVG values NNS . SENT Aardvark NN s PP method NN of IN asking VVG a DT thread NN for IN a DT single JJ stepping VVG run NN reason NN and CC empowering VVG the DT reason NN to TO accomplish VV its PP$ mission NN can MD be VB the DT basis NN for IN single JJ stepping VVG optimized VVN code NN . SENT Optimized VVN code NN generally RB interleaves VVZ instructions NNS from IN different JJ source NN lines NNS , , rendering VVG the DT standard NN execute VV instructions NNS until IN the DT source NN line NN number NN changes NNS method NN of IN single JJ stepping VVG useless JJ . SENT If IN instead RB the DT compiler NN emits VVZ information NN about IN the DT semantic JJ events NNS of IN a DT source NN line NN , , Aardvark NN can MD construct VV a DT single JJ stepping VVG run NN reason NN based VVN on IN semantic JJ events NNS rather RB than IN line NN numbers NNS . SENT Single JJ stepping VVG an DT optimized VVN HPF NP program NN immediately RB reaps VVZ the DT benefits NNS since IN logical JJ stepping VVG is VBZ built VVN on IN physical JJ stepping VVG . SENT Interpreted VVN Languages NNS Logical JJ entities NNS can MD be VB used VVN to TO support VV debugging VVG interpreted VVN languages NNS such JJ as IN Java NP 31 CD and CC Tcl NP . SENT 32 CD In IN this DT case NN , , the DT physical JJ process NN is VBZ the DT operating VVG system NN s PP process VVP the DT Java NP Virtual JJ Machine NN or CC the DT Tcl NP interpreter NN , , and CC the DT logical JJ process NN is VBZ the DT user NN level NN view NN of IN the DT program NN . SENT A DT logical JJ stack NN frame NN encodes VVZ a DT procedure NN call NN of IN the DT source NN language NN . SENT This DT is VBZ accomplished VVN by IN examining VVG virtual JJ stack NN information NN in IN physical JJ memory NN and CC or CC by IN examining VVG physical JJ stack NN frames NNS , , depending VVG on IN how WRB the DT interpreter NN is VBZ implemented VVN . SENT Variable JJ lookup NN within IN the DT context NN of IN a DT logical JJ frame NN would MD use VV the DT interpreter NN managed VVD symbol NN tables NNS rather RB than IN the DT symbol NN tables NNS of IN the DT physical JJ process NN . SENT Summary NN HPF NP presents VVZ a DT variety NN of IN challenges NNS to TO a DT debugger NN , , including VVG controlling VVG the DT program NN , , examining VVG its PP$ call NN stack VV , , and CC examining VVG its PP$ data NNS , , and CC user NN interface NN implications NNS in IN each DT area NN . SENT The DT concept NN of IN logical JJ entities NNS can MD be VB used VVN to TO manage VV much RB of IN the DT control NN complexity NN , , and CC a DT rich JJ data NN location NN model NN can MD manage VV HPF NP arrays NNS and CC expressions NNS involving VVG arrays NNS . SENT Many JJ of IN these DT ideas NNS can MD apply VV to TO other JJ debugging VVG situations NNS . SENT On IN the DT surface NN , , debugging VVG HPF NP can MD appear VV to TO be VB a DT daunting JJ task NN . SENT Aardvark NN breaks VVZ down RP the DT task NN into IN pieces NNS and CC attacks NNS them PP using VVG powerful JJ extensions NNS to TO familiar JJ ideas NNS . SENT Acknowledgments NNS I PP am VBP grateful JJ to TO Ed NP Benson NP and CC Jonathan NP Harris NP for IN their PP$ unwavering VVG support NN of IN my PP$ work NN on IN Aardvark NN . SENT I PP also RB thank VVP Jonathan NP s PP HPF NP compiler NN team NN and CC Ed NP s PP Parallel VV Software NP Environment NP run NN time NN team NN for IN providing VVG the DT compiler NN and CC run VV time NN products NNS that WDT allowed VVD me PP to TO test VV my PP$ ideas NNS . SENT References NNS and CC Notes NP 1 CD . SENT Programming NN Language NP Fortran NP 90 CD , , ANSI NP X NP 3 CD . SENT 198 CD 1992 CD New NP York NP , , N NP . SENT Y NP . SENT . SENT American NP National NP Standards NPS Institute NP , , 1992 CD . SENT 2 LS . SENT J NP . SENT Adams NP , , W NP . SENT Brainerd NP , , J NP . SENT Martin NP , , B NP . SENT Smith NP , , and CC J NP . SENT Wagener NP , , Fortran NP 90 CD Handbook NN New NP York NP , , N NP . SENT Y NP . SENT . SENT McGraw NP Hill NP , , 1992 CD . SENT 3 LS . SENT High NP Performance NP Fortran NP Forum NP , , High NP Performance NP Fortran NP Language NP Specification NN , , Version NP 2 CD . SENT 0 CD . SENT This DT specification NN is VBZ available JJ by IN anonymous JJ ftp NN from IN softlib NN . SENT rice NN . SENT edu NN in IN the DT directory NN pub NN HPF NP . SENT Version NN 2 CD . SENT 0 CD is VBZ the DT file NN hpf NP v NN 20 CD . SENT ps NNS . SENT gz NN . SENT 4 LS . SENT C LS . SENT Koelbel NP , , D NP . SENT Loveman NP , , R NP . SENT Schreiber NP , , G NP . SENT Steele NP , , Jr NP . SENT , , and CC M NP . SENT Zosel NP , , The DT High NP Performance NP Fortran NP Handbook NN Cambridge NP , , Mass NP . SENT . SENT MIT NP Press NP , , 1994 CD . SENT 5 CD . SENT MPI NP Forum NP , , MPI NP 2 CD . SENT Extensions NNS to TO the DT Message NP Passing NN Interface NP , , available JJ at IN http NN . SENT www JJ . SENT mpi NN forum NN . SENT org NP docs NNS mpi NN 20 CD html NN mpi NP 2 CD report NN . SENT html NN or CC via IN the DT Forum NP s PP documentation NN page NN http NN . SENT www JJ . SENT mpi NN forum NN . SENT org NP docs NNS docs NNS . SENT html NN . SENT 6 CD . SENT M NP . SENT Snir NP , , S NP . SENT Otto NP , , S NP . SENT Huss NP Lederman NP , , D NP . SENT Walker NP , , and CC J NP . SENT Dongarra NP , , MPI NP . SENT The DT Complete JJ Reference NN Cambridge NP , , Mass NP . SENT . SENT MIT NP Press NP , , 1995 CD . SENT 7 CD . SENT W NP . SENT Gropp NP , , E NP . SENT Lusk NP , , and CC A NP . SENT Skjellum NP , , Using VVG MPI NP Cambridge NP , , Mass NP . SENT . SENT MIT NP Press NP , , 1994 CD . SENT 8 CD . SENT J NP . SENT Harris NP et NP al NP . SENT , , Compiling VVG High NP Performance NP Fortran NP for IN Distributed NP memory NN Systems NP , , Digital NP Technical NP Journal NP , , vol NP . SENT 7 CD , , no RB . SENT 3 CD 1995 CD . SENT 5 CD 23 CD . SENT 9 CD . SENT E SYM . SENT Benson NP et NP al NP . SENT , , Design NP of IN Digital NP s PP Parallel VV Software NP Environment NP , , Digital NP Technical NP Journal NP , , vol NP . SENT 7 CD , , no RB . SENT 3 CD 1995 CD . SENT 24 CD 38 CD . SENT 10 CD . SENT It PP is VBZ possible JJ to TO always RB use VV logical JJ entities NNS , , but CC sometimes RB it PP is VBZ easier JJR to TO work VV with IN the DT building NN blocks VVZ when WRB additional JJ structure NN might MD be VB cumbersome JJ . SENT In IN a DT similar JJ vein NN , , Fortran NP could MD eliminate VV scalars NNS in IN favor NN of IN arrays NNS of IN rank NN 0 CD , , but CC Fortran NP chooses VVZ to TO retain VV scalars NNS because IN of IN their PP$ ease NN of IN use NN . SENT 11 CD . SENT In IN this DT policy NN , , nasty JJ and CC nice JJ are VBP generic JJ names NNS for IN categories NNS . SENT Which WDT particular JJ stop NN reasons NNS fall VVP into IN which WDT category NN is VBZ a DT separate JJ design NN question NN . SENT Once RB the DT category NN is VBZ determined VVN , , the DT policy NN presented VVN can MD be VB performed VVN . SENT 12 CD . SENT Debuggers NNS often RB build VVP a DT physical JJ call NN stack VV from IN innermost JJ frame NN to TO outermost JJ frame NN , , interleaving VVG construction NN with IN presentation NN . SENT The DT interleaving VVG gives VVZ the DT appearance NN of IN progress NN even RB if IN there EX are VBP occasional JJ delays NNS between IN frames NNS . SENT The DT total JJ time NN required VVN to TO reach VV the DT outermost JJ frames NNS of IN each DT physical JJ thread NN , , which WDT much RB occur VVP before IN construction NN of IN a DT logical JJ call NN stack NN can MD begin VV and CC before IN any DT presentation NN is VBZ possible JJ , , could MD be VB noticeable JJ to TO the DT user NN . SENT 13 CD . SENT An DT assumed VVN shape NN array NN is VBZ a DT procedure NN array NN argument NN in IN which WDT each DT dimension NN optionally RB specifies VVZ the DT lower RBR bound JJ and CC does VVZ not RB specify VV the DT upper JJ bound VVN . SENT For IN example NN , , REAL NP . SENT . SENT ARRAY NN ARG NP 2 CD D NP . SENT , , 4 CD . SENT A DT deferred JJ shape NN array NN has VHZ either RB the DT ALLOCATABLE JJ or CC POINTER NN attribute NN , , specifies VVZ neither CC the DT lower JJR nor CC upper JJ bound JJ , , and CC often RB contains VVZ local JJ procedure NN variables NNS or CC module NN data NNS . SENT For IN example NN , , REAL NP , , ALLOCATABLE JJ . SENT . SENT ALLOC NP 1 CD D NP . SENT REAL JJ , , POINTER NN . SENT . SENT PTR NP 3 CD D NP . SENT , , . SENT , , . SENT 14 CD . SENT An DT array NN section NN occurs VVZ when WRB some DT subscript NN specifies VVZ more JJR than IN one CD element NN . SENT This DT can MD be VB done VVN with IN a DT subscript JJ triplet NN , , which WDT optionally RB specifies VVZ the DT lower JJR and CC upper JJ extents NNS and CC a DT stride NN , , and CC or CC with IN an DT integer NN vector NN , , for IN example NN , , ARRAY NN 3 CD D NP ROW NN 1 CD . SENT ROWN NP , , COL NN 1 CD . SENT . SENT COL NN STRIDE NN , , PLANE NN VEC NP A DT field NN of IN array NN operation NN specifies VVZ the DT array NN formed VVN by IN a DT field NN of IN each DT structure NN element NN of IN an DT array NN , , for IN example NN , , TYPE NN TREE NN . SENT . SENT TREES NNS NTRESS NP REAL NP . SENT . SENT TREE NN HEIGHTS NNS NTREES NP TREE NN HEIGHTS NNS TREES NNS HEIGHT NN In IN general NN , , each DT of IN these DT specifies VVZ discontiguous JJ memory NN . SENT 15 CD . SENT DEC NP Fortran NP 90 CD Descriptor NP Format NN , , DEC NP Fortran NP 90 CD User NP Manual NP Maynard NP , , Mass NP . SENT . SENT Digital NP Equipment NP Corporation NP , , June NP 1994 CD . SENT 16 CD . SENT The DT HPF NP array NN descriptor NN for IN the DT variable JJ ARRAY NN in IN the DT HPF NP fragment NN . SENT HPF NP TEMPLATE NN T NN NROWS NP , , NCOLS NP . SENT HPF NNS DISTRIBUTE VVP T NN CYCLIC JJ , , BLOCK VV REAL JJ . SENT . SENT ARRAY NN NCOLS NP 2 CD , , NROWS NP . SENT HPF RB ALIGN VV ARRAY NN I PP , , J NP WITH IN T NN J NP , , I NP 2 CD 1 CD contains VVZ components NNS corresponding JJ to TO each DT of IN the DT ALIGN VV , , TEMPLATE NN , , and CC DISTRIBUTE VV directives NNS . SENT Often RB an DT array NN is VBZ distributed VVN directly RB , , causing VVG the DT ALIGN VV and CC TEMPLATE NN directives NNS to TO be VB implicit JJ , , for IN example NN , , REAL NP . SENT . SENT MATRIX NN NROWS NP , , NCOLS NP . SENT HPF NNS DISTRIBUTE VVP MATRIX NN BLOCK NN , , BLOCK NN 17 CD . SENT The DT variable JJ SCALAR NN in IN . SENT HPF NP TEMPLATE NN T NN 4 CD , , 4 CD . SENT HPF NNS DISTRIBUTE VVP T NN CYCLIC JJ , , CYCLIC JJ . SENT HPF RB ALIGN VV SCALAR NN WITH IN T NN , , 2 CD is VBZ partially RB replicated VVN and CC will MD be VB stored VVN on IN the DT same JJ processors NNS that IN the DT logical JJ second JJ column NN of IN the DT template NN T NN is VBZ stored VVN . SENT 18 CD . SENT R SYM . SENT Cohn NP , , Source NP Level NP Debugging VVG of IN Automatically RB Parallelized JJ Programs NNS , , Ph NN . SENT D SYM . SENT Thesis NN , , Carnegie NP Mellon NP University NP October NP 1992 CD . SENT 19 CD . SENT HPF NP User NP Group NP , , February NP 23 CD 26 CD , , 1997 CD , , Santa NP Fe NP , , New NP Mexico NP . SENT Information NN about IN the DT meeting NN is VBZ available JJ at IN http NN . SENT www JJ . SENT lanl NN . SENT gov NP HPF NP . SENT 20 CD . SENT In IN a DT trip NN report NN , , DIGITAL's NP representative NN Carl NP Offner NP reported VVD the DT following NN . SENT Many JJ people NNS complained VVD about IN the DT lack NN of IN good JJ debugging VVG support NN for IN HPF NP . SENT Those DT who WP had VHD seen VVN our PP$ Aardvark NN based VVN debugger NN liked VVD it PP a DT lot NN . SENT . SENT . SENT . SENT An DT industrial JJ HPF NP user NN complained VVD emphatically RB about IN the DT lack NN of IN good JJ debugging VVG support NN . SENT . SENT . SENT . SENT Another DT industrial JJ HPF NP user NN s VVZ biggest JJS concern NN is VBZ the DT lack NN of IN good JJ debugging VVG facilities NNS . SENT 21 CD . SENT Prism NN User NP s PP Guide NP Cambridge NP , , Mass NP . SENT . SENT Thinking VVG Machines NP Corporation NP , , 1992 CD . SENT 22 CD . SENT CM NP Fortran NP Programming NN Guide NP Cambridge NP , , Mass NP . SENT . SENT Thinking VVG Machines NP Corporation NP , , 1992 CD . SENT 23 CD . SENT TotalView NP . SENT User NP s PP Guide NP Dolphin NP Interconnect NP Solutions NNS , , Inc NP . SENT , , 1997 CD . SENT This DT guide NN is VBZ available JJ via IN anonymous JJ ftp NN from IN ftp NN . SENT dolphinics NNS . SENT com NN in IN the DT totalview JJ DOCUMENTATION NN directory NN . SENT At IN the DT time NN of IN writing VVG the DT file NN is VBZ TV NP 3 CD . SENT 7 CD . SENT 5 CD USERS NNS MANUAL JJ . SENT ps NNS . SENT Z SYM . SENT 24 CD . SENT PGHPF NP User NP s PP Guide NP Wilsonville NP , , Ore NP . SENT . SENT The DT Portland NP Group NP , , Inc NP . SENT , , 1997 CD . SENT 25 CD . SENT KAP NP Fortran NP 90 CD for IN Digital NP UNIX NP Maynard NP , , Mass NP . SENT . SENT Digital NP Equipment NP Corporation NP , , October NP 1995 CD . SENT 26 CD . SENT Fine NP Tuning NP Power NP Fortran NP , , MIPSpro NP POWER NN Fortran NP 77 CD Programmer NN s PP Guide NP Mountain NP View NP , , Calif NP . SENT . SENT Silicon NP Graphics NPS Inc NP , , 1994 CD 1996 CD . SENT 27 CD . SENT Compilation NN Control NN Statements NNS and CC Compiler NN Directives NNS , , DEC NP Fortran NP 90 CD User NP Manual NP Maynard NP , , Mass NP . SENT . SENT Digital NP Equipment NP Corporation NP , , forthcoming JJ in IN 1998 CD . SENT 28 CD . SENT Release NN Notes NNS for IN Digital NP UNIX NP Version NP V NN 4 CD . SENT 0 CD D NP Maynard NP , , Mass NP . SENT . SENT Digital NP Equipment NP Corporation NP , , 1997 CD . SENT 29 CD . SENT The DT Thread NN Attribute NN , , in IN Microsoft NP Visual NP C NP . SENT C NP Language NP Reference NN Version NP 2 CD . SENT 0 CD Redmond NP , , Wash NP . SENT . SENT Microsoft NP Press NP , , 1994 CD . SENT 389 CD 391 CD . SENT 30 CD . SENT CF NP 90 CD Commands NNS and CC Directives NNS Reference NN Manual NP Eagan NP , , Minn NP . SENT . SENT Cray NP Research NP , , Inc NP . SENT , , 1993 CD , , 1997 CD . SENT 31 CD . SENT J NP . SENT Gosling NP and CC H NP . SENT McGilton NP , , The DT Java NP Language NP Environment NP . SENT A DT White NP Paper NP May NP 1996 CD . SENT This DT paper NN is VBZ available JJ at IN http NN . SENT www JJ . SENT javasoft NN . SENT com NN docs NNS white JJ langenv NN or CC via IN anonymous JJ ftp NN from IN ftp NN . SENT javasoft NN . SENT com NN in IN the DT directory NN docs NNS papers NNS , , for IN example NN , , the DT file NN whitepaper NN . SENT ps NNS . SENT tar NN . SENT Z SYM . SENT 32 CD . SENT J NP . SENT Ousterhout NP , , Tcl NP and CC the DT Tk NP Toolkit NP Reading NN , , Mass NP . SENT Addison NP Wesley NP , , 1994 CD . SENT Biography NN David NP C NP . SENT P NN . SENT LaFrance NP Linden NP David NP LaFrance NP Linden NP is VBZ a DT principal JJ software NN engineer NN in IN DIGITAL JJ s PP High NP Performance NP Technical NP Computing NP group NN . SENT Since IN joining VVG DIGITAL JJ in IN 1991 CD , , he PP has VHZ worked VVN on IN tools NNS for IN parallel JJ processing NN , , including VVG the DT HPF NP capable JJ debugger NN described VVN in IN this DT paper NN . SENT He PP has VHZ also RB contributed VVN to TO the DT implementation NN of IN the DT Parallel JJ Software NP Environment NP and CC to TO the DT compile VV time NN performance NN of IN the DT HPF NP compiler NN . SENT Prior RB to TO joining VVG DIGITAL JJ , , David NP worked VVD at IN Symbolics NP , , Inc NP . SENT on IN front JJ end NN support NN , , networks NNS , , operating VVG system NN software NN , , performance NN , , and CC CPU NN architecture NN . SENT He PP received VVD a DT B NN . SENT S NP . SENT in IN mathematics NN from IN M NP . SENT I PP . SENT T NN . SENT in IN 1982 CD . SENT Trademarks NNS DIGITAL JJ is VBZ a DT trademark NN of IN Digital NP Equipment NP Corporation NP . SENT CRAY NN is VBZ a DT registered JJ trademark NN of IN Cray NP Research NP , , Inc NP . SENT Microsoft NP and CC Visual NP C NP are VBP registered VVN trademarks NNS of IN Microsoft NP Corporation NP . SENT TotalView NP is VBZ a DT trademark NN of IN Dolphin NP Interconnect NP Systems NPS , , Inc NP . SENT UNIX NP is VBZ a DT registered JJ trademark NN in IN the DT United NP States NPS and CC other JJ countries NNS , , licensed VVN exclusively RB through IN X NP Open NP Company NP Ltd NP . SENT Legal JJ Legal JJ Statement NN Privacy NN Statement NN