Eindhoven University of Technology

MASTER

APL-machine : een systeemstudie voor een efficiente APL-implementatie

Bruinsma, S.J.

Award date:1981

Link to publication

DisclaimerThis document contains a student thesis (bachelor's or master's), as authored by a student at Eindhoven University of Technology. Studenttheses are made available in the TU/e repository upon obtaining the required degree. The grade received is not published on the documentas presented in the repository. The required complexity or quality of research of student theses may vary by program, and the requiredminimum study period may vary in duration.

General rightsCopyright and moral rights for the publications made accessible in the public portal are retained by the authors and/or other copyright ownersand it is a condition of accessing publications that users recognise and abide by the legal requirements associated with these rights.

• Users may download and print one copy of any publication from the public portal for the purpose of private study or research. • You may not further distribute the material or use it for any profit-making activity or commercial gain

L"ri=~ eH!.: hOGCSCHOOlENDHOV_rJ

STUDiUj'DUOTJ lEEK~iELlJ . j-- : ....,- .., ,:1-

L -_" .v. _.'..... , *1.I....:r\ .(!-~--------.".~1J;6 t ""-,,,<,~.

TECHHISCHEH 0 GES C H 0 0 L

E I H D H 0 V E ti

~PL-MACHIHE

door S.J. Sruin3~~.

Ir. J.P. Ke!'\perIr. M.P.·J. stevens

INHOUD.

1. SJlJl\o.nvoltting .2. Inl~iding .3. Ori~ntolti~ op het i~pleAenteren vo,n APL ..

3.1 Typerende kenl'lerl<en VQn APL .3.2 Oe tweef~sen-structuur in APL .3.3 SIlAenllo.tting APLZeO .

4. Een syste9Astructuur voor een efficiente APL-Ao.chine.4.1 De workspl1ce .

4.1.1 De IJ- en de F-workspo.ce ..4.1.2 Opbouw .... 'ln een APL-da.tQ.-ob.ject.

4.2 De workspa.ce-Pll1na.ger .4.3 Oe ASCrr-APL-Col'lpiler ..

4.3.1 Het ta.ble-segAent.4.3.2 Het code-segMent ..4.3.3 Het da.tOo-segAent ..4.3.4 Het source-segAent.

4.4 De CQ~piler Output Processor.4.4.1 De COP-operolting-sIJstePl-tQ.a.k.4.4.2 De APL-exeCytion-ta.Ook .

5. Een Priptiti..,e Function Processor .5.1 BlokscheAIl van een PFP .5.2 Twee koltllgorien vOon pri!'litive functions ..5.3 De APU Input Controller .5.4 De APU Output Controller .5.5 De Arithl'letic Processing Unit ..5.6 De PriMitive Function Controller ..5.7 De COP en APL priMitive functions.5.8 HUMerieke da.tol in APL .5.~ PFP Illgoritl'len ..

5.9.1 Bo.sis \1001' PFP-a.lgoritl'len ..5.9.2 Voorbeeld ..5.9.3 Overzicht .

5.10 GekllsK'ldeerde PFP' s '" ..5.10.1 De AOC/AIC~operQ.tionl'lode 2.5.10.2 Gebruil<sAogeli.jkheden.

6. Conclusies .r Litera.t.lJur ..Appendix Al APLZ80 .Appendix 8: PFP-lllgoritAen.

blz.

123:3467'3'3

.10

.10

.11

.12. .. 13. .. 14

.14

.15

.15

.16

.17

.17

.20

.20

.23

.25

.27

.29

.33

.34

.34

.35

.38

.41

.42

.42

.45

.46

.47

.53

1 -

1. SAMENVATTING.

Dit iS het versldg v~n het ~fstudeerwerk van S.J. BruinsMa,v~rricht in het kader van Zijn opleidin~ tot elektrotechnischingenieur ~~n de Technische Hogeschool te Eindhoven in deperiode deceMber 1980 - deceMber 1981.

In dit ~fstudeerwerk is onderzocht hoe APLgeiApleAenteerd zou kunnen worden op een Machinestructuur nog een vrijheids9r~ad w~s.

efficientI.rlaarvtln de

D~ bestudering von APL in het algeMeen en de ~nalyse vanAPLZ80, een softwtlre APL-iMpleAenttltie geschikt voor~icrocoMputers Aet een CP" disk-operating-systeAJ hebben geleidtot het inZicht ddt er in APL in de runfa.se van progrCll'\l'lQ'Sa.ltijd een interpreterfunktie tlanWezig Moet Zijn. APL Ktln nusneller verwerkt worden als er partlllel aan de @xecuti~ va.n eenpri~itieve funktie een volgende opera.tie geinterpreteerd kanworden.

Het interpreteren indefinitie-fase VtlnplQtltsvindt. In ditAogetijk is.

APL kan versneld 'worden a.ls er in deprograA~a's een verre9~ande Co~pilQtie

versltlg wordt a~ngegeven in hoeverre dit

APL wordt gekenMerkt door een gegener~liseerde toepûssin9 va.npriMitieve oper~ties op ~eerdiMension~le dtlta.structuren. Hetexecuteren van APL-opera.ties k~n d~n versn~ld worden door~clresberekeningen ~~n oper~nd-ddt~ p~rallel ~Qn de eigenlijke;unktieberekeningen uit te voeren en dit te co~bineren Metd~t~-prefetchjng. Op deze b~SiS gestoeld wordt in dit versl~9

e~n speci~le processor voor het executeren VQn APL pri~itive

functions en oper~tors beschreven.

Vervolgens wordt de e~eëutie v~n APL pri~itive functions enoper~tors ~fgebeeld op processen die in deze speci~le processorgerealiseerd Aoeten worden. Deze processen worden be~chreven ineen ALGOL-Qchti~e t~Ql.

Tenslotte wordt nog de Mogelijkheid ~Qngegeven OA ~eerdere vandeze speci~le processoren in k~sk~de te schakelenJ wa~rMee eena~nt~l APL-expreSSies ineens geexecuteerd kan worden.

2-

2. INLEIDING.

APL is ~e~ problee~gerichte progr~~Aeert~~l ~et een kr~chtige

set priMitieve oper~ties, gecoAbineerd Met een zeer COMp~cte

not~tie. Het iS bovendien een interaktieve t~al w~~rin zowelrekenkundige ~ls ddta-M~nipulerende operaties opMeerdiMensionale datastructuren Met priMitieve funktiesondersteund worden.

APL is d~n ook een hoge-orde progr~~MeertQ~l die, Mede door hetinter~ktieve k~r~kter v~n de t~~l, op een speelse MQniergeleerd kQn worden en geen verregnnnde progr~MMeerV~Qrdigheid

vereist. (Zo ontbreken in APL bijVOorbeeld v~riQbele-

deel Q.t'o.t i es).

APL-iMpleAentaties worden vrijwel altijd in softw~~e opbesta.ande MQchineS gerealiseerd. JUist OAdüt het gebruik v~nAPL weinig progr~~Aeer-ervaring en systeeMinzicht vereist, Moetde softwQre nu een stuk ~erk overneMen d~t in ~ndere t~len doorde progra.MMeur gedo.an wordt. Het gevolg iS dat e~n g~geven

problee~, beschreven in APL, Meer tijd rtodig h~~ft O~ tot deoplossing te ko~en dan do.tzelfde probleeA beschreven inbijVOorbeeld FORTRAN (Mits gerunned op dezelfde ~~chin~).

In dit ~rstudeerYerk iS gezocht n~~r Mogel ijkheden voor eenAPL-i~ple~entatie die sneller is dnn volledige softw~re-

i I'Iplel'lentllt i es.

Voor het vervolg v~n dit versl~g iS het wel eenl~zer over een zekere APL-basiskennis beschikt.niet vertrouwd Aet APL kQn ik ~a.nrQden het boek(litet'a.tuur Cl]) te lezen.

ver~iste da.tLezers, nogvan Klltz'ln

3-

3. ORIENTATIE OP HET IMPLEMENTEREN VAN APL.

In deze p~r~gr~~f worden e~n twe@t~l ~spekten Y~n APL beh~ndeld

die ~in OT ~eer direct een ~~nt~l funkties iApliceren die ineen APL-iAp\e~ent~tie gere~liseerd zullen ~oeten worden.

Vergelijkt ~en APL ~et ~ndere hogere progr~~Meert~len d~n VQltop dQt APL geen v~riQbele-decl~r~ties kent. Een vQri~bete in~PL krijgt p~s r~nkJ type en sh~pe op het Mo~ent d~t er dQt~

Q~n toegewezen wordt. Wordt er in een IQter stQdiUA v~n eenprogrQA~Q een nieuw dQtQobject ~Qn die vQriQbele toegewezen,dQn worden type, rQnk en shQpe eventueel QQngepQst. DezedynQ~iSche eigenschappen VQn APL-vQriQbelen hebben tot gevol9dQt er geen vQste geheugenruiMte voor ~Qri~beten gereserveerdkQn worden. ( TenZij er een MaXiMale OMvang voor APL­dQtQobjecten wordt Qfgesproken, W~Qrn~ voor iedere vQriabeleeen geheugenblok yan deze afMeting wordt gereserveerd. Ditresulteert in een zeer inefficient geheugengebruik en bovendienZijn er Q\tijd wel situaties te bedenken w~Qrin de gekozen~QXiMQte oftv~ng te klein is. ".~.w. dit iS geen reeeluitgQogspunt). De vereiste geheugenruiAte voor variabelen kandoor het progra~~Qverloop steeds ver~nderen. In het geheugenzullen dus gaten v~llen doordat een d~tQobject groeit en dQQrOMop een Qndere plaats wegge~chreven Aoet worden of doordQt eend~tQobJect kleiner wordt en dQn a~n Minder geheugenruiMtevoldoende heeft. .

Kort SQAengeVQt:V~ri~beten in APL hebben dynQAische eigenschQppen M.b.t. type,rQnk, sh1lpe en de pl~~ts ~~n de dQt~ in het geheugen. Dezedyn~Mische eigensch~p A.b.t. pl~~ts in het geheugen heeft totge~o19 d~t er een ~echQnlsAe "oet bestQ~n d~t inforMQtie overvrijko~ende geheugenblokken verwerkt en Qktie onderneeMt OM

deze vrije geheugenblokken weer ten dienste VQn het progr~~MQ

te kunnen stellen.

APL wordt verder gekenMerkt door een gegenerQtiseerdetoep~ssin9 VQn priAitieve funkties op MeerdiAenSionQledQt~structuren. Dit feit en het gegeven dQt type en structureVllYl een APL-vat'iQbele dynQl'liSch ziJn, J'ilrl~kt d~t er in ieder..­APl-i~pleMent~tie een interpreter ~~nweZi9 Moet Zijn. Dezeinterpreter Moet QfhQnkelijk van de Mo~ent~ne type- enstructure-eigensch~ppenVQn vari~belen de jUiste verwerking VQneen priMitieve funkti..- garanderen.

4-

3.2 D~ tweer~sen-structuur in APL.

In het werken Aet APL kunnen twee fasen dUidelijk onderscheidenworden.

D~ eerste fase iS de definitiefase. In deze f~se wordenYserd~fined functions regel yoor regel ~erwerkt en in deworkspace weggeschre~en. Bovendien ~ordt hierin infor~atie

gegenereerd w~aruit de sa~enh~ng ~dn regels Uit een ~n dezelfdefunktie dT te leiden vdlt.

De tweede fase in APL iS de executiefase. In de e~ecutiefase

worden de in de definitiefdse bewerkte userdefined functionsuitgevoerd. Het iS vooral deze fase die de ~erwerkin9stijd ~an

APL-pro9r~AA~'s ~oor een groot deel bepaalt.

APL-verwerking in de zogena~~de calculator~ode betekent niets~eer dan dat deze beide fasen autOft~tisch na elkaar doorlopenworden. In feite iS hier sprake ~an de defaultfunctionKevalu~te input" die Onftiddellijk uitgevoerd wordt.In het vervolg ~an dit ~ersldg wordt de calculdtor~ode adn ookniet apart behandeld. Als er sprake iS ~an APL-~erwerking, ddnwordt hierAee het verwerken ~an userdefined functions bedoeld.

ScheRatisch voorgesteld Ziet iedere APL-i~ple~entatie er Uitzoals geschetst in fig 1. De definitiefase wordt in deze figuurgerepresenteerd door het blok uASCII-APL-COMP!LER", deexecutief~se door het blok uCOMPILER-QUTPUT-PROCESSORu.

Ce~traQI in iedere APL-i~ple~ent~tie staat de ~orksp~ce. DeworksPQce bevQt userdefined functions, APL-d~taobjecten ensystee~p~ra~eters. Een essentieel onderdeel van de workspace iSde sy~bolt~ble. In het QIgeMeen z~l de uASCII-APL-COMPILER"v~riabelen~Men verv~ngen door entries in een sy~boltQble

(H~shin9). O~dat de locatie ~an d~ta die ~et v~ri~belen

verbonden iS niet sttltisch is, legt de sYRboltable d.lIl.v. eenin iedere entry opgenOMen pointer de aktuele link tussen' een\lariabelereferentie en de dadrbij behorende data..

De t~Qk van het blok ·WS-MAHAGERu is reeds even kortdangestipt. De wS-ftanager dradgt zorg voor het beheer van Vrijegeheugenblokken in de workspace en heeft hiertoe twee tdken tevervullen.

1) Bij ~Q.nvrQ.ag ~Iln geheugenruiMte Met een gegeven groottedoet de wS-Mllnager een toeWijZing.

2) Bij teruggtlve vlln een geheugenblok zorgt de wS-~QnQ.ger datdit blok weer gebrUikt kan g~an worden \loor anderegeheugenrui~te-Q.Qnvragen.

· -~.~._-,...._"_._-- _.-

- 5-

LJSER

IA/PUT

tiscrr/lPL

COftP/LER

W01U: S. P/1 CE

C.OI7PIL ER

OUTPUT

PRoCéS..(O!?

WOR~ S"P,.iC EHlfAJA6 E. R

Figuur 1. APL tweefasen-structuur.

6-

3.3 S~Menv~tting APLZ80.

In eerste f~se v~n dit ~fstudeerwerk iS de softw~re

interpreter APLZaO ge~n~lyseerd. Deze ~n~lyge h~d totinzicht te krijgen in een APL-i~pleAent~tie.

APL­doel

De "ASCII-APL-COMPILERR,. de ·WORKSPACER en de ·WS-MAHAGER M inAPLZaO worden besproken in ~ppendiX A. Oe bel~ngrijkste conclu­sies Uit de ~n~lyse v~n APLZaO worden hier kort s~Aengev~t.

Oe cOMpiler in APLZaO iS zeer bescheiden v~n opzet. Afgezienv~n het verv~ngen v~n n~"en door entrynUA"erS in de sYMboltdbleiS het niets ~eer d~n een char~cter voor ch~r~cter vertalingv~n de sourcecode Uitgebreid Aet w~t ~~nvullende inforA~tie

betreffende de structuur v~n die regel. Verder wordt iedereregel voor~fge9~~n door linked-list inforA~tie w~~r"ee regelsVdn een en dezelfde funktie in de juiste volgorde saAengehoudenworden. Deze bescheiden cOApi leropzet heeft tot gevolg ddt desyntax en seAantiek van een regel APL in de executief~se

volledig ge~n~lyseerd ~oet worden.

Progr~~-flow-control iS in APLZ80 een nog~l tijdrovendebeZigheid. Bij een sprong na~r een regelnuMAer Roeten de last­1 ine en next-line pointers in de linked-list inforAatiest~psgewijS n~~r de jUiste regel leiden. Bij een sprong naar~en lIbel Aoeten ~lle regels doorlopen ~orden totdat het jUistel~bel aan het begin van een regel gevonden wordt.

Oe wS-Aan~~er in APLZaO is eveneens heel eenvoudig uitgevoerd.In APLZeO wordt slechts een groot blok Vrij geheugenverondersteld. Dit blok iS d~n in de top van de workspacegelokaliseerd. Hls er geheugenruiAte door het progr~MMa wordtvrijgegev~n, d~n wordt de hele wS-inforAatie opgescho~en zoddtdit blokje geheugen deel 9llt uitftlken Vln het grote blok Vrijgeheugen. Bij dit schuiven van de ws-inforMltie worden d~n ookalle pOinters gecorrigeerd.

M.b.t het snel verwerken v,n APL-progrdMRa's iS APLZ80dUidelijk niet efficient opgezet. VerMoedelijk ~ordt ditveroorzaakt door het feit dat Ren slechts een rel~tief kleingeheugen ter beschikking heeft. In APLZ80 iS er dlles "nged~'n de ws-ruiMte zo goed Mogelijk te benutten. <De ws-ruiRte:s SYSTEM RAM - CPM - 32 K)

7-

4. EEN SYSTEEMSTRUCTUUR VOOR EEN EFFICIENTE APL-MACHrNE.

D~ inZichten, verkregen door de bestudering ~~n APL in hetalgefteen en de analyse van de software-iMpleMentatie APLZ80,vorMen de bnsis ~oor een hier te presenteren systeeft-structuurvoor het efficient i~pleftenteren v~n APL. De aanduidingefficient betekent in dit verb~nd d~t APL-prograMMa's snelverwerkt kunnen worden. Het funktioneren vnn een APL-ft4ChineMoet d~artoe in twee richtingen geoptiMaliseerd worden;

1) Zo~ls Uit figuur 2 blijkt iS hier spr4k~ v~n een systeeMMet een Anster en een dantal sldve-processoren. Deftasterprocessor iS in_ deze opzet ....er~ntwoordel ijk voor deAAC-(ASCII-APL-CoI'lPi lel") en de COP-(COl'lpi ler-Output­Processor)-taken. De AAC en de COP Zijn nooit tegelijkdktief en kunnen dus Ret een en dezelfde processorgerenliseerd worden. Het eigenlijke interpreteren .... an APLgebeurt in de COP. Deze structuur heeft i n de execut iefdse.... an APL-progrdl'll'ln's het voordeel ddt er pdrdtlel adn deuit .... oering vnn een operatie va~k een volgende operntie inde COP geinterpreteerd kan worden. Dit iS e .... eneens de redenIJddrOI'l de workspa.ce in twee delen, die .... in verschi llendebussen toegankelijk Zijn, .... erdeeld is.

De opera.ties die in APL gedefinieerd Zijn kunnen over devolgende k4t~90rien .... erdeeld wo~den:

1) systeA f~nctions/coMAnnds

2) shn~ed v~ri~ble functions3) pri~itive functions/oper~tors

4) forAa.t pril'litive fun~tions

S) fil~ functions

Deze indeling is ontleend a.an de Burroughsleiding_ (literatuur "(2] ). De .... erschillendeworden hierin uitgebreid beh4ndeld.

APL-h'lnd­k'ltdgorien

Priftitive functions/oper~tors, forftat priMitive functionsen fi te funct ions kOPlen zeker in aanAerki n9 OM !'let externeprocessoren gerenliseerd te worden. De initi~lisntie v~n

externe processoren gebeurt ddn door de COP.

SysteA functions/coA~ands

kunnen beter in softwaregei~ple~enteerd worden.

en sha.red variabie functionsin de COApiler-Output-Processor

- B-

F - WOR K SPACE V- vvó1?/( !,p,A-c E

~ ~

N & - """"It'Eq A ....GI1TE

.A ...)... ... ~ y , 11"

'".,.

1 l 1 .

A ho.p~/"'/TIIIE -IIITEifteuP7

Á ... ~ B,~r .. ...

'FUfoJCrJONl. ti.... .... .... .....- s.... .,.t4R

A ....Fo~,.,t+T I... &

CO PA .... '"

.,.I11ITv -v Fq~t:1"' 0 NJ ... ....

~ ~ rE

C"PJOLII?

A .. I...IC FIL.EA .. .... .,.fJl+C IJlT... .,. Ft/Ale TltPA/ r A ....

r .... 11"

•OJS I( .

Piguur 2. structuur van een APL-machine.

Een in de run'~se optiAale APL-~~chine k~n verder bereiktworden door een weloverwogen t~akverdelin9 tussen de AAC ende COP. Hier~ee k~n het interpreteren in APLgeopti~~\iseerd worden. In hoofdstu~ 3 is er ~l op gewezendat er in APL ~ltijd een interpreterfunktie in deexecutier~se ~4nwezi9 ~oet Zijn. In de definitier~se k~n ereen cOApller gebruikt worden. Bij de ta~kYerdelin9 zo~ls

die in dit versl~g wordt voorgesteld iS de volgendedefinitie Y~n interpreteren in APL gehanteerd:

Interpreteren in APL iS het ~fbeelden v~n een gegeven APL­oper~tie plus de (dyn~Aische) type-, r~nk- en shape­eigensch~ppen van de oper~nden voor die oper~tie op eenreeks V4n ~kties die de jUiste verwerking V4n die oper~tie

tot gevolg hebben.

o~ een ÄPL-~achine volledig te opti~aliseren ~oet ook deexecutie van eleflent~ire APL-oper~ties geopti~aliseerd

worden. In dit afstudeerwerk iS onderzocht hoe de executievan pri~itive Functions/operators in externe processorenefficient gei~pte~enteerd zou kunnen worden. In hetvolgende hoofdstuk wordt hier nader op inge9a~n.

4.1 De WOt'kSpolce.

4.1.1 De '.!- en de F-worl<space.

De workspa.ce best~~t nu Uit twee delen, de V-workspace(v~ri~ble-~orksp~ce) en de F-workspace (function-workspace).

De F-worksp~ce bev~t gecoMpileerde$y~bolt~bt~s en systeeMp~r~Meters.

hoofdz~kelijk infor~~tie die de COPoper~ties te kunnen interpreteren.

userdefined functions,De F-worksp~ce bevat

nodig heeft o~ ele~entolire

De V-workspace be~~t de d~t~ die ~et APL-oper~nden geassocieerdiS. Deze d~ta wordt voor~l in de executie-f~se geaccessed.

Uit het vervolg \I~n dit lIerslQ.g zal bi ijket' da.t de COP 001<

toegang tot de Y-workspa.ce Moet kunnen krijgen. Hiertoe i$ ereen "GATE~ n~a.r de V-workspacebus opgenoRen.

- 10-

4.1.2 Opbouw VQn een APL-dQt~object.

Een APL-d~tQQbject best~~t Uit drie delen:

een sYAbolt~blepointer.

een objectdescription.een dQ.t~rietd.

D~ sy~bolt~blepointe~ iS een terugverWijZing n~a.r de sy~bol­

ta.ble di~ geb~uikt wordt tijdens een worksplc~-reor9a.niSQtie.

(z i e 4.2 , De workspQce-l'I~nl1ger)

De objectdescription bevQt het type. dehet cl~tQ.objfct. De objectd~scription iShet interpreteren va.n APL.

ra.nk en de sha.pe va.nnO'Jdztlkelijk tiJdens

Het datl1field beva.t de da.ta-ele~enten in row ~Q.jor order.

EI~ Zij n nu twee I'\ogel ijkheden voorobject in de workspQce.

1) Het d~tQobject stQa.t in z'n geheel Ln de V-'.Jorkspilce.2) De objectdescription ~Q~kt deel Uit Vtln de sYMbolttlble in

de F-worksp~ce en het d~tQfield stn~t, voorafgegaQn door desYAboltdblepointer, in de V-worl<sp~ce.

De eerste oplossing heert als na.deelinterpreteren de funktie-uitvoering inonderbreken OA een objectdescriptionkunnen lezen of schrijVen ..

dtlt de COP bij hetsl~veproces~oren Moetin de Y-wQrksp~ce te

De t~eede Oplossing heeft ~ls nQdeel d~t de sYAbolt~ble brederM~et worden, ~a~r heeft ~ts voordeel dat de COP toegang heefttot objectdescriptions zonder externe processen te onderbreken.

In het vervolg ..,.~n dit- versl'lg IJordt verondersteld da.t dp.objectdescription deel uitMQakt v~n de sYAbolt~ble-infor~Qtie.

Voer de ws-~an~ger iS in deze systeeMopzet eveneens gekozenvoor een ~p~rte processor Met eigen lokaal geheugen. Deze Moetde ~d~inistr~tie va.n de Y-worksp~ce bijhouden.Hiertoe Moet opverzoek een geheugenblok toegewezen worden en VrijkoAendeblokken Aoaten weer in de adMinistrQtie opgeno~en ~orden. HetschuifRech~nisMe zoals dat in RPLZ80 werd toegep~st iS te

11 -

tijdrovend. reden w~~ro~ een ~nder geheugenbeheer~ech~nis~e

~oet warden toegep~st. Verschillende Aogelijkheden vaor eendY~QAiSch geheugenbeheer worden besproken in liter~tuur [3].

(Dikt~~t besturingspro9r~~A~tuur 1, p~r~9r~~f 5.4.2.1ToewijZin9s-str~tegien.)

Een geschikte Oplossing lijkt l'Iij I hoe\tlel het geheugeninefficienter gebruikt wordt, het zogen~~l'Ide buddy-systeel'\. Indit systeel'\ \tlordt geheUgenrui~te toegewezen ~et een lengte diebep~ald wordt door een herh~~!de v~ste deelverhouding tussentoe te Wijzen rui~te en Vrije rui~te in een blok geheugen.

Als een geheugen~~nvrQQ9 niet gerenliseerd kQn worden ZQI ereerst een ws-reorgnnisntie plQ~ts Moeten vinden. De ws-~~nQger

ZQI hiertoe inforMQtie I'\oeten genereren W~Qr~ee dezereOr9Qnis~tie (= verplQQtsen v~n d~t~objecten) uitgevoerd k~n

worden.

4.3 De ASCII-APL-Col'lpiler.

De uitg~n9spunten voor het deFinierenCOl"lpiler Zijn de volgende:

va. n ÀSCII-APL-

1) Het .:ûi"lp i teren ka.n regel voor rege I gebeur-en i n de def i­nitiefo.se Vil" userdefined functions en is ~einig kritisch~et betrekking tot de tijd o~d~t deze fns~ gekenMerkt~ordt door een inter~kti~f proces tussen Mllchine engebrUiker. De enigste eis Met betrekking tot snelheid diein deze fa.se Q.~n het syste~A gesteld ~oet worden bestQ.QtdQ~rYit da.t een ~kseptQbele responstijd voor de gebruiker!"loet kunnen worden gega.ra.ndeerd.

2) Het interpreteren vlln APL ~oet pa.s ~ebeuren op het I"IDRentda.t dit echt noodza.kelijk is. Dit iS op het niVeQU VQn ,elel"lenta.ire opera.ties !"Iet APL-v~riQ.belen wo.nneerdynQi"liSche eigenscho.ppen v~n varia.belen bepQlen hoe deOperQtie Moet gllQn worden Uitgevoerd. In de executiefo.seAo.g dus geen a.no.lyse ~Qn APL-expressies ~eer noodzakelijkZijn. Dit betekent d~t er in de cOMpilerfQse een ~QntQI

systeeRvQ.ri~belen Aoeten worden ingevoerd w~Q.rl"lee APL­expressies tot een reeks eleMentQire opera.ties a.fgebrokenI,Jorden.

3) In de COi'\pi lerfnse I'\oeten eveneens 1'Ia.a.tregelen l40rden g~­

nQ~en OM snel bra.nch-instructies uit te kunnen voeren.

- 12-

Tijdens het function-editting-proces wordt hiertoe in de F­worksp~ce een geCO"pi leerde versie ~~n de userdefined functionS~"engest~ld. Deze gecoApileerde versie best~at uit viersegMenten plus een record Ret pointers naar de verschi llendes~~Menten of onderdelen hierv~n. De segRenten Zijn:

1 ) Een tablesegl'lent.2 ) Een r.:odesegl'lent.3 ) Een dl1to.segl'lent.4 ) Een sourcesegl'\ent.

De verschillende segl'lenten zullen nu besproken worden.

4.3.1 Het t~ble segl'lent.

Het tablesegRent bestQQt Uit Vijf tabellen.

!n de eerste t~bel is pl~ats gereserveerd voor o.ctualpo.ral'leters die bij de functioncall worden doorgegeven. Dezetabe! wordt beschreven bij het o.~nroepen van de funktie. No. hetQ,o'nroepen VQ~ en terugkeren uit een funktie gao.t het prograMMo.verde~ in een ander logisch blok. In het o.lgeMeen verandert nude sco~e vo.n variGbelen. Bij het binnengal1n vo.n een funktieworden o.~. actual paro.l'leters gekopieerd wo.o.rna deze kopien o.o.nde forMo.l po.ro.Meters worden toegewezen. Bij het terugkeren Uiteen funktie wordt eventueel de d~to. v~n een forMal~esultpo.r~~eter toege~ezen ~~n de o.ctuo.l resultpl1ro.Meter zod~t

het result~at buiten de fun~tie bekend wordt.

Eer. tweede to.bel bevat de lck~le v~ri~belen v~n die funktie.(ror~~l pBr~Reters Zijn ook lok~le v~ri~belen).

de flJnktiede "ege I

invlln

Een derde tabel besto.~t Uit een I ijst wangebrUikte l~bels ~et d~~rüchter het nUMRerw~arno.~r het lo.bel ver~iJst.

L~bels ~orden ook üls lok~le v~ri~belen beschouwd. Voord~t Metde Uitvoering van de funktiebody begonnen wordt, krijgen lok~le

v~riQbelen een o.ktieve stQtus. Yo.ri~belen die buiten het blokreeds een aktieve st~tus h~dden worden nu op een stQck gesûved.A~n IQbels wordt vervolgens het overeenkOMstige regelnuMMer ~ls

d~to. toegeldezen.

Een Vierde t~bel bev~t een lijst van regelnuMMers Metdûürûchter relatieve pointers naar het begin Vûn die regel inhet codesegl'lent. Deze to.bel wordt gebrUikt OA snel br~nch­

instrukties Uit te kunnen voeren. Voor grote progr~MRQ.'s kûndeze tabel wel l~ng ~orden. Een ûltern~tief i~ dûn OM

- 13-

bijVOorbeetd iedere Vijrde or tiende regel in deze t~bel op tene~en. Het begin v~n tussenliggende regels k~n d~n in het code­segMent opgezocht worden. Iedere nieuwe regel APL begint in hetcode-$eg~ent ~et een procedure CALL STATE-UPDATE.

Een l~~tste t~bel tenslotte best~~t Uit een lijst v~n in hetcodesegMent gebruikte kon$t~ntereferenties ~et d~~r~chter eenret~tie~e pointer n~~r de pl~~ts in het dat~seg~ent W~~~ ded~t~ v~n deze konstQnte gevonden k~n ~orden.

4.3.2 Het codeseg~ent.

Het codeseg~ent bestQ~t uit een reeks procedure-c~lls Metp~r~Meters. Iedere procedure voert een eleMentQire operatieuit. De co~piter heeft hiertoe een ~~nt~t s~stee~v~rj~belen

ingevoerd ~Q~r~ee een APL~expressie tot een reeks ele~ent~ire

h~ndetingen iS Qfgebroken. Deze systee~v~ri~belen Zijngenu~Merd Tl t/A Tn en Zijn per definitie lokQ~l t.O.v. iedereuserdefined function. In de F-~orkspQce iS d~~rtoe voor dezeT's een tweede s~~bott~ble ingevoerd. Het ~ini~u~ Qant~l T'sd~t nodig iS OA een expressie ~f te breken is o.~. ~fh~nkelijk

VQn de hQ~kjesstructuur die in de expressie gebrUikt is. Vooreen expressie zonder h~~kjes Zijn twee VQn deze T's voldoende.In dit Qfstudeerwerk is niet verder gezocht n~~r h~t AiniA~le

~~nt~l T's dQt voor APL-expressies v~n v~rierende COAptexiteitnoodza.kelijk is. Essentieel iS d~t er in de funktiedefinitie­f~se e~pressies ~fgebroken ~oeten worden OMdQt dit ~nders in de~~eCYtier~s~ Aoet gebeuren wQ~rdoor er extr~ overhe~d ontst~Qt

die ver~eden h~d kunnen worden.

In de volgende voorbeelden wordt globQ.~1 ~Qngegeven wa.t er v~n

de 'col'lpiler verw~cht \JIordt. De verschillende expresSies in ditvoorbeeld MQken deel uit v~n dezelfde userdefined function enZijn in opeenvolgende regels gedefinIeerd. Het ~Q.nt~l T's indit vDorbeeld iS zes.

C1l R"-A+B-C+D-E

COl'lpi ter output: CALL STRTE-UPDATECALL SUB (T1JDJE)CALL ADD (T2,C/Tl)CALL SUB (T3,B/T2)CALL ADD (RJAJT3)

- 14-

[ 2 1 R +- R+R

cOl'\piler output: CALL STATE UPDATECALL ADD (T4.R,R)CALL ASSIGH (R,T4)

[31 R +- 3 to.ke A rota.te B

COl'\p i let' output: CALL STATE UPDATECALL ROTATE(T5,A.B)CALL TAKE(R.Kl.TS)

Kl iS een pointer oo.a.r een entrydeze to.bel Ka.n vervolgens dedo.to.segl'\ent gevonden worden.

[4J R+- +/[ 112 4 ,-ho iota. 8

in de to.bel vlln Konsto.nten. Inplo.o.ts vo.n de d~ta. in het

COl'lpiler output: CALL STATE UPDATECALL IOTA (T6,K2)CALL RESHAPE (Tl,K3,T6)CALL REDUCTIOH (+.l,R.Tl)

Er !'loeten dus drie soorten pointers onderscheiden worden:pointers no.o.r de user-sYl'lbolta.ble.pOinters no.Oor de T-to.ble.pOînt~rs nQ.o.r de to.bel va.n konsta.nte-referenties.

4.3.3 Het do.to.segl'lent.

Het da.to.segl'lent beyo.t de ~Q.tQ. vo.n konsto.nten die in de funktiegebruikt worden. Ho. het o.fsluiten vo.n de funktiedefinitiefo.sewordt er bij de wS-l'Io.no.ger geheugenruil'lte o.o.ngevrQ,o.gd voor hetda.to.segl'lent da.t vervolgens nQ.o.r de V-workspo.ce wordtovergeschreven. Konsto.nten Zijn hierdoor toego.nk~lijk voore~terne processoren.

4.3.4 Het sourcesegl'\ent.

H~t reconstrueren va.niS in het o.lgel'leen

de soureecode u i t de gecol'\p i 1e~rdeniet eenvoudig. Bij het sQ.ven va.n

vet'siecopy-

- 15-

obj~cts ~oet echter ~el de sourcecode ges~ved ~orden. Bij het1aden !'loet de funkt ie na.Mel ijk opn i euw gecoPlp i 1eerd wOt'denOMdat de uitkoMsten Vdn HQ.shfunkties Q.nders kunnen Zijn.Bovendien iS het h~ndi9 01'1 bij foutPleldingen de pl~Q.ts vQ.n defout in de souree ~Q.n te kunnen geven.

4.4 Oe COl'lp i ler Output-Processor.

De COP verwerkt het codesegl'lent zOQ.ls dQ.t door de AAC gegevenwordt. Dit codese9~ent bestQ.Q.t in feite, zOQ.ls in de vorigeparQ.grQ.Q.f iS Q.angegeven, uit een progrQ.MMQ. wQ.arin proceduresa.Q.n~eroepen worden die een elePlentaire operatie representeren.

De COP heeft een tweetQ.l taken te vervullen,syst~A-tQ.Qk ~n een APL-ex.cution-taak.

4.4.1 De COP-operating-syst~l'l-ta.Q.k.

een opera.ting-

Eer. groot Q.a.nta.l operllties in APL il'lpliceren da.t er bij de ws­Pldr.ager geheugenruiPlte voor een resulta.Q.t wordt a.a.ngevra.agd. DeCOP Moet hiertoe Q.na.lyseren wat het type, de rank en de shapeVilr. het resultQ.a.t gQ.at worden. In de sYMboltQ.ble Moetvervolgens een nieuwe link nQ.Q.r de plQ.Q.ts in de workspa.ce waQ.rhet resultQ.Q.t ZQ.l kOMen te stQ.Q.n Q.Q.ngegeven worden. Oude dQ.tQ.~ie nog aQ.n een resultQ.Q.tvariabele WQ.S toegekend kQ.n nu uit hetgeheugen verWijderd worden door da.t geheugenblok aa.n de ws­l'lQ.nQ.ger terug te ge~en. In deze ~nalysefQ.se kunnen bovendien deeerste fouten herkend worden.

In een structuur ~~Q.rin sl~veprocessoren ver~ntwoordelijk Zijnvoor de Uitvoering vnn een ~~ntQ.l ele~ent~ire operaties heeftde COP verder een synchroniserende t~Q.k. SynchronisQ.tie iSbijVOorbeeld noodzQ.kelijk Q.ls er in het systee~ Aeerdere sla.vesZijn die ieder een bepQ.Q.lde kl~sse van operQ.ties voor hunrekening nePlen en de output V(ln processor 1 input voorprocessor 2 ~oet Zijn. In de sy~bolt~ble Moet daarOM vooriedere v~iQ.bele Q.angegeven worden of er Met die v~ri~bele

geldige dilt~ verbonden is.

Een tweede synchrOniSQtieprobleeM treedt op Qls ~r

~Qriabete opnieuw een resultQQt zou gQ.Q.n wordenterwijl d~ dQ.tQ. \ian die l/Q,riQbele nog (lIs input vooroperQ.tie gebrUikt wordt. De oude da.ta MQ.9 dQ.nverWijderd worden. In de sy~boltQ.ble ~oet dQaroM

~Iln eentoegel<end

een vorigenog niet001< \Iocr

iederegebruik

- 16-

v~ri~bele ~Qngegeven worden of die vQri~bele nogiS Qls inputv~ri~bele voor een OperQtie.

in

De hier SUM"ier besproken OperQting-syste~-t~Qk wordtuitgevoerd door de COP in SQMenwerking Met het blokinterruptverwerking. Hiertoe behoort ook het detekteren VQn eena~nt~l fouten en het QfhQndelen VQn foutcondities in hetQlgeAeen. De ex~cte i~ple~entQtie VQn deze operQting-systeA­t~Qk iS onder Meer QfhQnkelijk VQn de funkties die QQn slQve­processoren worden toebedQcht en de terugMeldingen die dezeprocessoren op hun beurt genereren. In dit Qfstudeerwerk iS

deze oper~ting-syste~-tQQk niet verder uitge~erkt.

4.4.2 De APL-execution-tQ~k.

Deze tweede tQQk v~n de COP bestQQt uit het uitvoeren VQn zQkendie dichter bij het verwerken VQn APL stQQn. Het eigenlijkeinterpreteren VQn APL gebeurt in de COP. De procedure-cQlls inde RAC-output kunnen dQ~rtoe in twee kQt~gorien ingedeeldworden.

De eerste kQtQgorie OMVQt die eleAentQire OperQties dievolledig in softwQre in de COP geiMpleMenteerd Moeten worden.In de executiefQse VQn een APL-progrQMAQ is de COP dus nQ hetinterpreteren eveneens belQst Met de softwQre-verwerking VQndeze operllt i es. H i ertoe behoren o. Q. :

Het bijhoude~ v~n de APL-stQte-indiCQtor.HQndelingen die voorQf 9QQn QQn het uitvoeren VQnv~n een userdefined function (p~r~~et~rp~ssing,

scope control)~PL br~nch- en QSsign-instructies

de bodyVQriolble

Dl? tt.leedl? kQtQgol'ie OI"lIlQt- eleAentQire oper~ties die l'Ietprocessoren gereQliSeerd worden. Hiertoe Moet de COP~lgeMeen enkele voorbereidende ~erkzQQMheden verrichten,de slQve-processor geinitiQliSeerd kQn ~orden enz~lfst~ndig de uitvoering VQn die OperQtie afhQndelt.

slQve­in het\oIQQrtHLverder

In het volgende hoofdstuk wordt n~der ingegQQn opexecution-tQdk v~n de COP voor APL pril'litive functionssl~veprocessoren gere~liseerd ~orden.

de APL­die l'Iet

- 17-

S. EEN PRIMITIVE FUNCTIOH PROCESSOR.

In h~t ~o~ige hoofdstuk is ~Qngeg@~~n dQt APL ~~nzienlijk

sn91te~ ~e~werkt k~n worden ~ls er p~r~llel ll11n hetinte~preterproces APL-funkties geexecuteerd kunnen worden. Ditinterprete~p~oces op Zijn beurt kOon weer sneller Zijn QIs ereen \ferrego.~nde COl'lpito.ti~fllse ~Qn voor'lf gQo.t. In dithoofdstuk wordt onderzocht hoe APL priAitive functions enoper~tors effectief, en dus snel, geexecuteerd kunnen wordendoor hier een geschikte processorstructuur voor te vinden.

5.1 Blokschel'lll vlln een PFP.

In hoofdstuk 3 iS ~eeds llo'ngegeven dO,t APL gekenRerkt wordtdoor een gegenerO,liseerde toepo.ssing vo.n pril'litie~e funkties op~eerdil'lensiono.le do.tllstructuren. Bij de uitvoering VQnpriMitieve funkties kunnen d~n ook twee soorten berekeningenonderscheiden worden:

Ildresberekeningen 01'\ een do.to.-elel'lent uit een lineO,ir geor­go.niseerd dQtQ-obj~ct te selecteren.de eigenlijke (rekenkundige) operQties !'Iet do.tQ-@lel'lenten.

Bij de hier voor te stellen slo.ve-processor voor APL pril'litivefur.ctions is dQn ook gekozen voor een benO,dering wIlllrbij o'dres­berekeningen ono.fhQnkelijk VQn en pO,rQllel ~~n funktiebere­kenIngen uitgevoerd worden.

Sc~eA~tisch voorge$t~ld ziet een pri~iti~e fYnction(oper~tor­

slQveprocessor, in het vervolg 'lf te korten tot PFP, el' o:foln l..litzo~ls geschetst in figuur 3.

De vier bel~ngrijkste bouwstenen zijn:

de ArithAetic Processing Unit (APU)de Pril'litille.Function Controller (PFC)de APU Input Controller (AIC)de APU Output Controller (AOC)

De ArC/s berekenen ~dressen '.lOon dat~-ele~enten volgens eenl,Ioor~f l,I'lstgelegd ~lgorit~e en hOoIen de dQt'l op uit de V­workspace. Deze d~ta wordt d~n in een queue gezet die door deAPU gelezen k~n worden.

- 18-

IIV T

E~~o-f

FLNe~

A?U. E"~-R~q

fic wlurt=

ERRoRCO"'!II"'!)

/1. ~ L"f

~ ~pre

~"'7 ~ V

Eo? -,f

Aoc ~.l'c-19 /'I/C -!3 " 'ê~-/JFCJO-8

~~E.rET

~~ 6 ~

~~7 ~7 ~7

MEl10RY BUJ

,

/Sus - /9~B/T~R

~

..

Figuur 3. Blokschema van een Primitive Function Processor.

- 19-

De APU k~n r9sult~ten w~gschrijven in de queue v~n de AOe, dieop Zijn beurt deze d~t~ volgens een voor~f gegeven ~dresbere­

kenings~l90rit~e in de V-worksp~ce wegschrijft.

Ee~ AIC/AOC k~n gezien worden ~ls een gebufferde DMA-bou~steen

Met uitgebreide prograAAeerAogelijkheden. Een Bus~rbiter regelt~elke POe/ArC toeg~ng krijgt tot de V-worksp~cebus. N~

beeindiging v~n een AOC/AIC-~190ritAe genereren deze bouwstenenee~ End of Operation. Deze signalen worden door de PFC ~ls

sy"chrOnisGtie-signalen gebruikt. De bus tussen de APU en deAOC/AIC heeft een tweeledige funktie. Yi~ deze bus yortit e~n

AOC/ArC door de PFC geinitialiseerd en de APU gebruikt deze busO~l d~tll te schrijyen en te lezen in respektievelijk de AOC eneen AIC. OMdat er drie v~n deze bussen opgenoAen Zijn kunnen erparallel twee dat~-eleAenten gelezen en een geschreven worden.

Een eerste tQ~k '.IQn de PFC iS het init.i~liseren vlln de AOe ende beide Are's. De PFC krij9t hiertoe initi~lis~tie-inforl'l~tie

..,.~n de COP. De PFC heeft toegang tot de APU-bussen ~ls de APUniet Ilktief iS (EOP-APU geset). Na. d@ initio.liSo.tie controleertde PFe de APL-funktjeuit~oerin9. De PFC genereert dl],o.rtoeopdrQ.chten voor de APU door een co~nQ.nd o.Q.n te bi~~en en eenCWRITE-si9n~al te genereren o.ls EOP-APU- o.ktief iS (f"lndsho.ke).Tot deze opdro.chten behoren ook Greo.d ArC-queue" en ~write AOC­queu@". FLAG is een t~rugRelding uit d~ APU ~~~rAee j~ PFC eenb~sl issing ko." ne~en over het verdere verloop vl],n de funktie­uitvoering. De APU-conditie ~Q.o.rop deze FLAG geset wordt ligtopgesloten in het APU-co""o.nd.

De APU tenslotte doet het eigenlijke rekenwerk. Voor ditrekenwerk kent de APU o.lle sCQ.l~ire prinitieve funkties die in

APL gedefinieerd zijn. Zo z~l de APU zelf onderzoeken of eenf~ctoriol-funktie Uitgevoerd "oet yorden ~\s fo.cult~itJ dlln wel~ls g~MA~f~nktie. Als er tijdens een berekening fout~n optredenwordt dit geneld ann de PFC en er ~crdt een error-cvde in heterror-register geschreven. No. een error-sign~at ge~ft de PFC deROe/AIC' s een softwo.re-reset en genereert een interrupt. In deinterruptver~erkingsroutinek~n dit error-register d~n gelezenworden. Bij beeindigin9 v~n een APL pri~itive function wordteveneens een interrupt gegenereerd.

Reset iS het power-up resetsign~o.l of eenPFC gegenereerde sort~~re M?dule-reset.

dOOI' de COP vio. de

Al\iorensb~kijken

p'1rI19r~'lf

de bOl..<lolstenen lI'1n deze PFP iets ·;Iedeto. i leerder teworden de APL pri~itive fynctions in de volgendein t~ee k~t~gorien ver~eeld.

- 20-

5.2 Tw~e k~t~90rien v~n pri~itive functiorrs.

Bij d~ i~ple~ent~tie v~n APL pri~itive fynctionsk~t~gorien functies onderscheiden worden:

d~t~-driven functions.non d~tQ-driYen functions.

k IJn ne n

Hon d~t~-driYen fvnctions Zijn funkties w~~rbij er ge~n

koppeting bestQ~t tussen de dQtQ VQn de operQnden voor diefunktie en de ~dresberekeningSQt90ritnen in de PFP. Non d~t~­

dl'iven flJoetion; kunnen n'l ... en ... enl'l~lige initia.lisatie V'ln deAOC en d~ beide AIC's voll ... dig afgehQndeld kunnen worden.

Bij d'lt~-driven functions besta~t er wel een koppeling tussen'ldresberekenings'llgoritMen en de dIltIl vün opera.nden voor eenfunktie. Oatll driven functions Moeten in Meerd~re stllppenuitgevoerd worden. Concreet betekent dit dQt de PFP op gez~tte

tijden opnieuw (ten del~) geinitialise ... rd ~oet worden. Zo isbijVOorbeeld in de Rotate funktie de d~t~ van ArC-A eenpllr'l~eter voor het adresberekenings-algoritMe in AIC-a. OM dezereden ~ordt de d~t~ ~Qn AIC-A bij iedere read ~~nuit de APU~utOA~tisch in een register in de PFC ingeklokt.

D~ze t~eedeling iS echter niet zo strikt ~ls hierbo~en

~~ngege.en. Een aantQI f~nkties die in principe d~t~-driven

Zijn kunnen door de COP een~oudi9 tot non d~t~-driven

getrQnSfO~Meerd ~orden 'lIs de data qlleen ~an invloed is opinitiele ~lgoritMe-p~r~M... ters. De reshape-funktie is hi ... rvane~n ·.. oorb~eld.

Eigent ijk best'lQt er nog een derde kQt~gorie funkties, n~~elij~

funkties WQQrin het resultQQt van een APU-bewerking hetexecutie-voortgang controlerende algoritMe in de PFCbeïnvloedt. Een voor.beeld van zo'n funktie is "MeMbership·.OMdat dit een indirect ge~olg is v~n de dQt~ vIln de operandenworden dit soort runkties eveneens tot de kQt~90rie "d~tll­

driven" gerekend.

5.3 De APU Input Controller.

De opbouw VQn de AIC iS geschetst in figuur 4. De ArC kent tweeoper'lt i on-l'Iodes:

N;)de 1:~'ode ,2:

De non-CQscQded ~ode.

De cQsc~ded Rode.

--- -- - ------ -- -

- 21-

lAl TE,f> F/fcEBuS

1~/r

wil.

REe

SELEc r

EoP

.oA'A

B/1"SE fr"-tJE I'1L6óR/"h~

ryPPFit 'llA-ItETER

Rét5/S TE/lS

Co~"'I1#()

r 1hEJf()R YREIf 0 J L,,"ST

ELEITEAIT

+ SEtfUE"C~

~UEI.CE.. /tL6oZt,.;'G

caNTre~L:;1 AI:

'\r... a~"o y

S~/TCH

Figuur 4. APU Input Controller.

- 22-

In dez~ p~rn9r~~f znl Aode 1 beh~ndeld worden. Mode 2de orde in p~rngr~nf S.10 <Gek~sk~deerde PFP's). HetSWITCH hQngt e~eneens S~Aen Aet oper~tion-Aode 2.

kOl"lt ~'ln

signtl~l

~~ AIC operntion-Aode 1.

In ftode 1 hnnlt de AIC d~tn voor de APU op uit de V-worksp~ce

volgens een voora.f gegeven ~190ritAe. De AIC bestn~t eigenlijklJit twee delen.

Het EleAent-Sequence-AI90rit~e berekent eleAentnuAAers va.nd~t~-eleAenten in een Row M~jor Order geor9nniseerd d~ttl­

object. Het cOAAandregister geeft hier n~n volgens welknlgorit~e deze eleAentnuA~ers gegenereerd Aoeten worden. Heta.tgoritMe gebrUikt hiertoe een nnntnl p~rtlAeters die inpa.rtlAeter-registers zijn opgesl~gen.

H~t blok "MEMORY READ + QUEUE-COHTROL Q gebruikteleAentnuAAers OA da.ta. in de V-workspnce te ndresseren end~ta. vervolgens te lezen. Hierbij worden de registers BASETYPE gebrUikt.

dezedeen

TYPE geeft tl~n hoeveel geheugen-~ccessen er geple~gd l"Ioetenworden OA een da.tn-eleMent in Zijn geheel in de d~t~queue tekunnen pta.ntsen. In een byte-georienteerd g~heygen ztllchnrncterda.ta. een byte per dnta.-eleMent gebruiken en flo~tin9

point bijvoorbeeld vier.

eerste dQ.t~­

TYPE direkthet Elef'lent­o genereert1 enz.), d~n

BASE iS het ndres vnn het eerste b~te v~n heteleMent v~n een v~ri~bele in de V-worksp~ce. Alshet nant~l bytes per d~t~-ele~ent ~angeeft enSeGuen~e-Algorit~e eteMentnuA~ers beginnend Aet(Het eerste ele~ent is nUM~er 0, het tweede nUM~er

wordt het lezen v~n d~t~-eleMent N beschrev~n door:

ADDRESS: =BASE+H*TYPE; .FOR 1:=1 TO TYPE DO BEGIN READ(ADDRESS);

ADDRESS:=ADDRESS+l:HfD.

De ArC IJordt geinitialiseerd door de PFC. De initinljs~tie-dl1tll

wordt geschreven over de APU-bus (locnt bus), Een adresvectorgeeft n~n in welk register deze d~tl1 geschreven ~oet worden<PARREGl .... PARREGtL SASE, TYPE, l-lODE, COI-l11AND) en de dlltn­overdr~cht wordt dGnrbij gesynchroniseerd door XACK volgend oprNITWR. Het beschrijven va.n het COAMtlndregister iS tevens eenqueue-reset si9n~nl en het stllrtsein voor de ArC. H~t EleMent­Seq~ence-Algoritf'le z~l vervolgens het eerste eleAentnuAMerberekenen, wn~rn(l ELEMENT-READY geset wordt. Dit e\eAentnuAAer

- 23-

wordt overgenoMen door het blok MEMORY-READ + QUEUE-COHTROL d~t

er de ~dressen voor berekent en vervolgens een BUSREQ voor deworksp~cebYs genereert. H~ een BUSACK ~ordt het e~rste d~t~­

eleMent gelezen en in de queue weggeschreven, w~~rn~ BUSREQteruggenoMen wordt. Het EleAent-Sequence-AlgoritMe heeftinMiddels een nieuw eleAentnuMAer berekend en ELEMENT-READYopnieuw geset. <Het EleAent-Seqyence-AlgoritAe ~oet dus snellerzijn dQn een AeMory-re~d/queue-~rite cyclus.) Oit nieuweeleAentnUMner wordt vervolgens overgenoMen, wa~rn~ ~r weer eenBUSREQ ged~~n wordt. NQ de BUSACK wordt het volgende datQ­eleMent gelezen uit de worksp~ce en weggeschreven in de da,ta.­queue, w~~rna. de bus tenslotte weer wordt vrijgegeven. Dezeworksp~ce re~d-~kties 9QQn door totd~t de queue vol is of deLAST ELEMEHT fliprlop door het EleAent-Sequence-Algorit~egesetwordt.

De da.tQ-queue kQn gelezen worden door de APU. De APU genereerthiertoe een RD-signQQI WQQrnQ de dQt~overdr~cht weergesynchroniseerd wordt door XACK <Dit is hetzelfde signaQI alsbij de initi~lisQ.tie). Het lezen .... Qn de da.tQqueue k~n

ona,fhankelijk VQn een Y-worksp~ce-rea.d-sequencegebeuren. Alsde queue leeg iS wordt XACK bij een APU-re~d pilS aktief a.ls erweer een dQ.ta,-ele~ent in Zijn geheel uit de V-~orkspa.ce gelezenis, dat diln direkt nQ.~r de APU doorgegeven wordt.

EOP wordt geset ~ls de APU hetheeft.<EOP werd gereset bijCOI'HIQndregister. )

IQatste da,ta.-eleMenthet beschrij .... en

gelezenvan het

RESET brengt de AIC in een gedefinieerde begintQest~nd.

5.4 De APU Output Controller.

Deo pbo uW",' Qn cl e A0Cis g"e sc het s tin f i 9 u u r 5. De A0 C I< ent, net~ls de ArC, twee opera.tionModes. ~ode 2 wordt weer beha.ndeld inp~rllgr~~f 5.10.

De APU Kan datQ sch~ijven in de AOe-queue. Dit iS ~eer

onafha.nkelijk Viln een V-workspa.ce write-sequence. In Mode 1wordt deze da.ta. volgens een gegeven algoritMe in de worksp~ce

~e9geschreven. De initialisa,t,ie en het funktioneren Viln de AOCiS in grote lijnen hetzelfde a.ls de Ale, ~lleen wordt er nu inde V-~orkspQce geschreven in plQ.Qts va.n gelezen.

-24-

IAJL r~R

R Et:SELECT

lSftSE Ht>I)~,<Jl C(JR I TH E

PItKÏll1é TERT'I~ë Réó'IST&l?

C()Hh/lN "

"EN~1i'Y élEl1e.N r

/AJ'i./rE L -'s T

otSé~UE#cé

QUEUE

~N~

~6()~/ThF

CON 71i!"L

L... ReltfJ Y.

SiAl/TOf

~AïA

Figuur 5. APU output controller.

- 25-

D~ AOC neel'lt data .... Iln de APU op in de da.ta.queue. Als de APU wi 1schrijven en de queue is vol, da.n wordt XACK voor de APU pilSa.ktief als er weer pla.a.ts iS in de da.taqueue. Het blok MEMORYWRITE + QUEUE-CONTROL zal elel'lentnu~~ers va.n het Elel'lent­Sequence-Algoritl'le o .... erneMen en en steeds proberen data­eleMenten uit de queue naar de workspa.ce te schrijven zolang dequeue niet leeg is. Ha. het schrijVen .... an een data-elel'lentwordt de Y-worksPQcebus steeds .... rijgegeven Ol'l een anderecontroller toegang tot de bus te kunnen ge .... en.

EOP wordt geset als het laQtste data-elel'lentgeschreven wordt.

naQr de workspace

RESET brengt de AOC weer in een gedefinieerde begintoestand.

S.5 De Arithl'letic Processing Unit.

De APU iS geschetst in fig. 6. De APU doet rekenkundigebewerkingen op data of wordt o.ls transfer-unit .... oor structurepril'litive functions gebruikt.

Opdrachten voor de APU kOl'len van de PFC, die hiertoe eencOl'l~andvector Qanbiedt. De cO~l'lo.ndoverdrllcht gebeurt !'let dehandshakesignalen EOP.-APU en CWRITE. <EOP-APU iS Ilktief, de PFCzet een cOl'll'land op de cOl'll'la.ndblJs, CWRITE wordt Qktief, EOP-APUZIlt hierop in-Qktief 1,lorden en CI.1JRITE '.tIordt weer teruggenol'len.)EOP-APU wordt o.ktief o.ls er een COl'll'lQnd uitgevoerd is ensynchroniseert zo de PFC cOl'l~a.ndstreQl'l.

In de PFC-col'll'lands kunnen een QQnta.l registers <getekend zIJner zes) plys FLAG geQdr9ss~erd worden. De PFC ziet ~e APU infeite als een drie-~dres ~~chine. Hieronder volgen enigevoorbeelden v~n PFC-co~M~nds die door de APU uitgevoerd Aoetenk'Jnnen "ol'den.

"a.dd<R,A,B)"" no t<R,B)""~OMpQre( FLAG, A, B)"".Iri te< AOC, R)"

"I'eo.d< 8, ArC-B)"

"rea.d< AOC,R);~lri te<A, AlC-A)"

R: =A +8R:= HOT 8FLAG wordt geset a.ls A=8schrijf register R in de AOC­qlJeUelees de AlC-B-queue en schrijfde dat~ in register Bschrijf regi$ter R in de AOC­queue en lees gelijktijdig deAlC-queue en zet deze dQta inregister A.

- 26-

A'PUCO t't/'tA"" 0

e~p

APU

l~CI(~pu

wR

~>j

,

PFc - IN 7 Z:~ F/'tC ë

- E c 6,.,rr/fAl.o .Jf,Et:IS 7'.G/f -

R~

~R

A~/TKnET/c

flt.b"R I 7A';A?$0 ~1(

ra ei RL

<: (j e

R A B

'"'oc A IC - A- ~/C- J!

,~rëfi:. J-AC é lAl "'E~ ~AC E INTëKFACe

~ ~,~

~~'r l·1~;tel(

Figuur 6. Ari~hme~ic Processing Uni~.

- 27-

Als er touten optreden wordt er een errorcode in hetregiter gezet en een fout~elding nnn de PFC doorgege~en.

kent de ~otgende foutMeldingen:

HUI'lBERLIKITIHTEGERLIMITTYPE-ERRORDOf'lAIH-ERROR

error­De AP IJ

De APU heeft drie onnfhnnkelijke interfnces voor de beide ArC'sen de AQC.

In de APU-registers zijn eveneens de systeeMp~r~Aeters IndexOriginl COAp~rison Toler~nce en RnndoA Link opgeslngen. OA dezes~steeAvnrinbelen te kunnen l~den ~oet er een sp~cinle PFC­funktie gedefinieerd worden.

RESET zet de APU in een gedefinieerde begintoestnnd.

5.6 De Pri~jtive Function Controller.

De PFC iS geschetst inDe PFC controleertfunctions.De PFC initinliseert

fig. ? en heeft twee taken te vervullen.de executie-voortgnng v~n APL priAitive

de beide Arels en de AOC.

Het blok UFunction-Control-AI90rithAs" controleert de executie­~oort9nng v~n APL priAitive functions en bestn~t danrtoe uiteen verznAeling ~tgoritAen VOor de verschillende funkties. Deinhoud v~n het cOAAandregister bepanlt welk nlgoritMe ergekozen wordt. De al9~ritAen gebrUiken paraAeters uit eenparaAeterfi Ie. SOAAige algoritMen gebruiken bo~endien de datavan AIC-A en weer andere genereren Return Dato die door ~e COPgelezen I'loet worden nis' de funktie IJitgelloerd is. Si.î ieder~

d~t~transfer op de AIC-A dntabus wordt deze dnt~ auto~atisch ineen PFC-r~9ister ingeklokt. Een APU-error~elding uordt geziennis ~en algoritAe-interrupt die tot g~volg he~ft dat deHOC/AICl s een sort~are-reset krijgen en de PFC eensystee~interrupt genereert. De PFC wordt gestnrt door hetbeschrijven van het Function-COAMand register. Ieder priMitivefunction-~lgoritp.e zal beginnen Met een CALL INIT wn~rMee d~

HOC/AICl s de eerste keer geiniti~liseerd ~orden. De output v~n

een pri~itive f~nction-algoritAe bestant uit APU-coMM~nds eneventueel een QQntnl CALl's nGar INIT-procedures waarin eenherinitiQtisatie of een reset gerealiseerd Yordt. APU-COMMQndsworden vi~ de APU-interface nQQr de APU gestuurd.

'~-----'-'-""-'-'- .---'--~ -~--~~-"-'---"

- 28-

pow i:R uP

RESBT

JOcKSELEcT

A

1

,f1.PU - lAl TëlrFACE

~

,,-PU - C o,.,,.,ItI<JD -1l~~IS TER

.....-.. FWJC.T/ON-.

-. coAJT~L.--..~L6(>RlïIlI7S

L

--r

I~

...-. "r

.l\J:J FI.JIKT IC N COI'TI7/fP t:)

Ir FA~A I'1ETëR F I L e .1/ T

ARE TlI/e1V ,019 rA

.A

HII r~ ~ CoAJT!?CL ~

~

~ ~oc - IA/IT .oH 'TA

~L.

IJle ·A - lAl /7 ,,/)H 'TA

<: L.

19 I C·13 - lAl I T ,() RTI'9 L"

ê::OP IA.l7E~F/'IcE

D Î~ ~

117

A -13lA

XAc I(

FLA&EeP-/ffJU

ED'P-REe>'-11EcP -6

It.EsET

Figuur 7. Primitive Function controller.

- 29-

Het blok "INIT eONTROL- v~rzorgt de AOe/ArC initi~lis~tie.

Hiertoe is er in de PFC rui~te gereser~eerd voor drie(ht~files.(lJoor ieder input/output controller een). Een AOC/!=IICdCltolfi le be .... a.t de p~rlll'leters en het cOI'lI'\a.nd. Deze fi les wordendoor de COP gege .... en. De Function-Control ~lgoritl'len hebbenevenens toegClng tot deze p~ra./'leterfi les. Ol'ld~t de adresbus IJi tdrie register-select vectoren is opgebouwd kunnen de AOC/AIC'Spllra.llel Voln initiollisoltie-da.ta. voorzien worden.(zie fig. 8)Het blok "IHIT CQHTROL- kent de a.dressen ..,a.n polral'leterregistersbij een gegeven AOC/AIC-algoritl'le en een voora.f gedefinieerdepolr~l'\etervol90rde.

De COPkunnenVerderSl~stel'l

I'loet vier dCltolfiles en het cOl'll'lQ.ndregister v~n

beschrij .... en en het Return Oa.ta. register kunnen\'loeten er PFC-funkties gedefinieerd ~orden voor

Interrupt en voor "odule Reset.

de PFClezen.Reset

5.7 De eo~ en APL pri~itive functions.

In de vorige PQrClgra.Qf werd ol~ngegeven da.t de COPpolroll'leterfi les plus een Function Control cO~Mllnd in de PFC /'loetSChrijven. (De AOC/AIC-col'll'l~ndlolords zitten in deollereenkol"lstige pa.r~ .. eterfi les.) Voor dyadische operaties Zijndit in het lllgel'leen vier p~ra./'leterfi les plus het FunctionControl cOAI'lClnd en voor 1'l0nQ.dische in het a1ge~een drie plushet Function Contra! cOl'll'land.

Interpreteren in de COP iS nu het ~fbeelden v~n eenoper~tie Met gegeven oper~nden op ~~XiA~~l vier ~lgoritAen

bijbehorende p~r~~eters.

APL­Plet

De 9~ng van z~ken in de COP voor het uitvoeren v~n eenpriAitive function is nu ~15vo19t:

De COP bepa~lt de obj~ctdescription v~n het result~~t van debewerking en vraolgt hiervoor geheugenruiAte a~n bij de~orksp~ce-~~nager.

N~ de toewijZing doet de COP een s~Aboltable-upd~te. (Even­tuele oude d~ta. die nog a.~n een result~~tv~riabele w~s

toegekend kan nu verWijderd worden door d~t geheugenbtok aande worksp~ce-Aa.nager terug te geven).Tenslotte bepaa.lt de COP de PFC-p~raAeterfiles plus hetFunction Control COAAQ.nd en initialiseert de PFC. (De PFCz~l nu de ACe/AIC's initialiseren, waarAee de funktie­el<ecutie gest~rt is.)

-30-

...V) Ilo\ '" 00') ~

~.... ~ ~ ::s~Q'J~ ~

Cl:) ~ ~, I ,~

~ AQ ~I

~ ti:.?

~/

~n4

~,

i/~-

~ I ~

~/'

~A..~ <t'

VL ~I

U

/ / -vi

~

~V

~u0

/<l::.

vi

Piguur 8. Local Address-Data-bus.

- 31-

In het ~oorgQ~nde werd Qls een ~Qn de COP-werkzQQ~heden

aQng9ge~en dat de COP geheYgenrYi~te voor het resyltQQt ~Qn eenbe~erking QQn~raa9t bij de de ~s-~nnager. De COP Aoet dus bijeen gegeven APL-operatie uitzoeken wnt de objectdescription VQnhet resulta~t van de bewerking gaat worden. Met betrekking totdeze COP-funktie ku~nen de APL pri~iti~e functions/operQtors indrie klassen verdeeld worden:

1) Pril'\itive functions loperl1tors wal1rbij Yit de gegevenOperQtie en de objectdescription<s> VQn de operQnd<en) deobjectdescription vnn het resyltQat afgeleid KQn worden.

2) PriAitive functions w~arbij nnast de objectdescriptionook de data vnn een operQnd geinspekteerd Moet ~orden o~

de objectdescription VQn het resultQat te kunnen bepalen.

3 ) Pril'\itive functionsresultant PQS bekend

wQQrbij de objectdescription VQn hetis nQdnt de funktie iS uitgevoerd.

Het resultaat van funkties uit klnsse 3 iS Qltijd een vector.Het is wet 1'I0gel ijk een bovengrens voor de lengte VQn deze~ector Qno te"geven, I'\QQr de exacte lengte is pas bekend Qls defunktie iS uitgevoerd. <Deze lengte· stQQt dQn in het DQtQReturn regi ster. )

In tQbel 1 wordt voor iedere APL pri~itive

Qa.ngegeven 'tot welke IdQsse deze behoort.

De funktie -evQluQte- is niet in deze ta.belvoor deze funktie eerst een cha.ra.ctervectorworden. De COl'lpi Ier-output bestQ.Qt dan weerOperQties die wel in de t~bel voorko~en.

function-opera.tor

opgenopAen o~dQt

geco~pileerd /'loetIJit elePlentaire

Al_orens een PFP-QIgorit",e /'let de bijbehorende PQrQ.Pleter bere­keningen te bespreken wordt de volgende pnra.grQQf ge~ijd Qo.neen diskussie over nu~erieke dQta in APL.

- 32-

pi tiMes 1circ. functions 1

fa.ctorio.l 1cOl'lbina.toria.l 1

bllse e power 1bllse e log 1power 1log 1

not 1a.nd 1or 1no.nd 1nor 1

funktie kla.sse

integers 2index in 1

ra. .... e 1 1cntena.te 1lnl'lino.te 1

re..,ers@ 1rotnte 1

tra.nspose 1perl"lute 2

cOApress 2expa.nd 1

ta.ke 2drop 2

gra.de up 1gro.de down 1

rol 1 1den1 1

bo.se lIo.1ue 1represent 1

I'la.trix in .... erse 1l'Io.trix dil/ide 1

outer product 1inner product 1

reduction 1scnn 1

l'Iel'lbership 1s IJb se t 1slJperset 1!Jnion 3intersection 3exclusion 3

11111

11

1111

11111

k1nsse

less 1not greo.ter. 1equo.l 1not less 1grea.ter 1uneqlJo.l 1

funktie

identitynego.tesignul'lreciprocnte\'tllg" i tIJde

a.ddslJbtrllctIHlltiplydivideresidlJ~

f100rcei1ingI'linil'lu",I'l l1X i AUA

selectQ,ssign

sho.pe 1resha.pe 2

to.bel 1.

- 33-

5.8 NUMerieke data. in APL.

In de vorige para.qra.af is opgeA~rkt dat d~ COP d~ objectdes­cription va.n het resulta.at bepa.a.tt. Tot deze objectde~cription

behoort OOK het type va.n de do.ta.. In principe bestaan er voornt..lJllerieke da.to. dri9 types: boolea.n, inteqer en rea\. Booleanszijn een subset yqn integers die weer een subset Zijn vanrea.ls. Een a.a.nta.l APL-opera.ties stelt eisen Met betrekking tothet type van de opera.nden voor die operatie. Dit betek~nt

echter niet da.t er drie ~erschillende soorten da.ta-objecten inAPL Moeten bestQ.a.n. Is dit wet zo, dan brengt dit de volgendeprobleJllen Aet zich Plee:

Bij een verJllenigyuldiqing van twee integer-da.ta.-objecten za.lhet resultaat ook integer Zijn. Yoora.f kQ.n niet overZien wordenof er integeroverflow zo.l go.an optreden, dus zo.l het resultaatin APL het type reo.t krijgen. Als dit resulto.at vervolgens eenoperand voor een funktie wordt wQ.arin geeist wordt da.t dieoperand uit integers bestaQ.t, dan !'loet in die funktieonderzocht worden of dit reo.ltype-data.-object uit gehelegeta.tlen besta.at. Zo zullen integer- en rea.ltype dQ.ta.-obje~ten

ook a.ls opero.nd ~oor bijvoorbeetd togische funkties toegestaa.nzijn. In het atgeJlleen za.l voor iedere sca.lar-pril'litive functionhet resultao.t-type bepaald worden door de opero.tie en is iedernUl'leric dato.-type geoorloofd ~ts operand. Oit heeft tot gevol9d~t er ~en veelheid aa.n conversi~-routines geiApleMenteerd Moetworden.

Het voorstel is dan ook OM stechts een forAa.~t voor nUAeri~Ke

d~ta te h~nteren, en wel re~t. Hier~ee wordt bereiKt dat o.lleAPL priMitive functions en -opero.tors op een uniforMe wijZeKunnen worden ~fgeh~ndeld. De:e optossin9 heeft t~ee (kleine)na.deten:

op byte-bo.sis kost het in een ao.nta.t geva.l­da.ta-ete~enten uit het geheugen op te ha.len

De beschikba.rebruikt.Plet een geheugenten I'leer tijd OP!

geheugenrui~te wordt Minder efficient ge-

H~t eerste no.deel wordt geco~penseerd door de (toch nog steedsdo.lende) prijs ~o.n geheugen en het a.dresseringsbereik va.nModerne processoren, het t~eede Ka." gecoMpenseerd worden doord~t~ op te halen voorda.t deze voor een opero.tie gebrUikt gQ.Q.tworden (da.to.-queueing)

- 34-

Eer. ~olledige beschriJ~in9 ~~n door ~ij geiApleAenteerdepriAitive functions wordt gegeven in ~ppendix B. In dezep~r~gr~~f ~ordt de basisged~chte ~chter de constructie ~~n deze~lgoritAen toegelicht, w~~rn~ ~ls ~oorb~eld de i~pleAent~tie

van dy~dic scal~r priAitive functions behandeld wordt.Ter.slotte wordt er een overzicht gegeven v~n de in de PFPgeiMpleAenteerde priAitieve funkties.

5.9.1 B~Sis ~oor PFP-algoritAen.

D~t~-objecten in APL hebben een rechthoekige structuur. Dezestructuur wordt beschreven door de rnnk en de sh~pe v~n hetd~ta-object. In de constructie v~n AOC/ArC-~190rit~en zullensteeds drie ~spekten terugkoAen:

Gege~en:

Een data.-obj ect D l'Iet rank R en sh~pe rhot 1 J. .. rho[ R 1.

1) De afstand tussen twee elel'lenten die enkel en a.lleen inde Kde dil'lensie een indexpositie verschillen bedr~Q9t:

d=rhoCK+1]* *rhotR] /lIs K HEG Rd=1 a.ls K=R.

2) 0 kan ~erdeeld worden in rhoC1]* ..... *rhotK-l] blokken '.lOonrhoCK]* .... *rhoCR] eleAenten. Ieder blok k~n weer verdeeldlol 0 r cl e n "i n r h 0 [ K] blo k ken 1/ a. n r h 0 [ K+1 ] *. . . . . . . . . . . . . * r hoC R]eleMenten.

3 ) In iedere priMitieve funktieresultQ~t in Row M~Jor Order te

iS er naar gestreefd hetgenereren.

Ter.slotte ~oet nog verl'leld worden d/lt APL v~n rechts n~Q.r linksgeeva.lueerd wordt. Dit heeft tot gevolg d~t in bijvoorbeeld eenreduction-sequence voor een vector de eleMenten in reversedorder gegenereerd worden.

- 35-

5.9.2 Voorbgeld.

Als voorbeeld worden nu de dy~dic sc~l~r priAiti~e functionsbeh~ndeld. Voor dy~dic sc~l~r pri~iti~e functions best~Qn ertWge \Jorl'lenl

1) R4-A dspf B2) R~A dspf[KJ B

Voor d@ eerste vorft Zijn de ~190rit~en voor de beide AIe's ende AOe Ro~ ~~jor Order ~190rit~en. Het R~O ~lgoritAe genereertel.~entnul'l~ers in inde~-volgorde. Het R"O-~lgoritAe gn~t ~ls

volgt:

AIC/Aoe RMO:BECIN eleAent:=-1;

FOR count:=l TO nUl'lber DOBEGIH eI9~ent:=elel'lent + 1i

CALL ADDRESS(elel'lent)iENDi

END.

Het st~tel'lent CALL ADDRESS(eleAent) betekent~l.l'lentnuMMer een a.dres ber~kend en eenUitgevoerd !'loet worden.

da.t './001" ditI'le!'lol"'~-sequence

Het RMO-QI90rit~e heeft nIspQra.l'leterberek~ningen iS hetresult~~t 'lIs v~n de oper~nden

- R'lnk- Sh~p~[l J. ..... ShQpe( R'ln\( J.

~e berekening v~n nu~ber is ~ls

p~rQl'leter nUAber nodig. Voornoodz~kel ijk dOlt V'lll- zowel het

~l bekend Zijn:

volgt:

AIC/Aoe Rr10 PAR:BEGIN n lJMber:=l;I:=U

WHILE I LEQ r'lnk 00BEGIH nU!'lber:=nul'lber*sh~pe(I]

1:=1+1;END;

E ~l 0 .

In het PFC-a,lgoritl'le wordt een v~riQbele REACCONTROL ing~voerd

voor het geva.l d~t A of B een sca.l~r of single is. Deze ka.n dewa,'lrden 0,1,2 of 3 hebben.

REP.OCO~ITROL =0READCOHTROL =1REP.DCO~ITROL =2READCOHTROL =3

- 36-

A en B zijn b~iden sc~l~r of single.A iS sCdldrlsingle en B niet.B is sCdl~rlsin91e en A niet.A en B Zijn best~an beiden uit ~eer adn eenelel"lent.

PFC DSPF:BEG H~ CAL L I HI. T

"redd <Ad,rC-A), reOod (B,AIC-B)";"dspf (RtlLB)";~HILE HOT (EOP-A ~nd EOP-B) DOBEGIN DO CASE READCOHTROL

O• •. ,l:"redd (B,AIC-B), write (AOC,R)"2:"rea.d <A,AIC-A), ""rite (AOC,R)"3: a rea.d <A,AIC-A)' rea.d (B,AIC-B), write (AOC,R)"

"dspf (R,A,S)";EHO;"write (AOC,J~)"i

WHILE not EOP-R DO nothing:" interrupt";

EHD.

De pa.r~~eters voor dit Q.lgorit~e Zijn READCONTROL en "dspf". Depa.ra.l"leter "dspf" is een code voor de gewenste dya.dic sca.la.rpriAiti~e function.

De tweede vorM vOon d~Oodic sca.lOor priAitive functions eist vooreen VO,n de opera.nden een nieuw ddresberekeningsa.lgoritAe: HetCoerced Order a.lgoritMe

AlC CO:BEGIN eleMent :=-1;

FOR countl:=1 TO repl DOBEGIN FOR count2 :=1' TO reop2 DO

BEGIN FOR count3:=f Ta rep3 DOBEGIN elel"lent :=eleAent+1;

CA~L ADDRESS(~lel"lent);

EHD;eleMentl=~leMent-r~p3;

EH 0;eleMent:=ele~ent+rep3i

EHO:EHD.

- 37-

Dit ~l90ritM~ eist drie p~ra,~eters

~oor de oper~nd "et het kleinsteberekening wordt gerefereerd Q~n de(R). De po.r'IlJlleters worden a.ls I/olgt

en !'loeta,~nta.l

structuurberekend:

toegepdst wordeneleAent~n. In de

va.n het result~a.t

Arc co PAR:BEGIN IF K=l THEH rep! :=1

ELSE rep 1: =rsha.pe( 11* ... *rshJlpe( K-11;rep2:=rsh~pe[Kl;

IF K=rra.nk THEN rep3:=1ELSE rep3: =rsh'1peC K+1 1* ... *rsha.pe[ rr'lnk 1;

EHD

Het PFC-a.lgorit"e ka.n voor deze tweede VOl""

blijven. Dya.dic sc~lQ.r pri"itive functions zijn nonf:JI'~ct i ons.

Als: A= 2 2 3 rho iot'1 12B= 2 3 rho i 0 t ol 6

d'1.n wordt A+[21B:

2 4 6S 7 ~

11 13 1514 16 18

De AOe en de AIC-A generere~ nu de ele~entnul'lMers

o 1 2 3 4 5 6 7 S 9 10 11

AIC-B genereert de elel'lentnul'lAers:

o 120 1 2 3 4 534 5

IH[ 1 lB r,;ordt:

246S 10 12

a 10 1214 16 18

012345012345

,>n.~ew i j Zi gdda,l;,a.-driven

In tabel 2I'10gelijkh~den

- J8-

een overzicht gegeven vanAPL pril'litve functions.

de il'lplef"lenta.tie-

Betekenis vqn de code:

* volledig gei.l'lplel'lenteerd.niet te if"lplel'lenteren.

? iflllpleAenta.tie wel ,.,ogelijk, l'la.ar nog niet gere~liseerd.

De funkties Q.Qngeduid f"Ietworden.

SelecL Assign.

zulten nu besproken

Selection iS in het ~lgel'leen een f"Ieer dan dyadische operatie.De PFP is hier'.. oor niet geschikt. Selection ZOI..! wel in I'\eerderesl~gen Uitgevoerd kunnen worden. Als de l'la,xil'lQ.al toegesta.nera."k .... a,n een var ja.bele op a,cht gesteld ·wordt, da,n Roet er eeninde~-vector uitprodukt vlln a,cht a.riabelen gevorl'ld worden.V~rvolgens !'loet uit iedere index- ector een elel'lentnul'll'lerberekend worden. Als deze elel'lentnul'l,.,ers nu da.ta-input !'loetenworden voor een AIC-A, dan is selection een data-drivenfunction va,n de ergste soort ol'ldat AIC-B dlln voor ieder da.ta.­eleMent opnieuw geinitia,lis~erd l'loet worden.Assign is een sYl'lboltabl~-M~difica.tie die door de COP wordtIJ i tgevoerd.

Sha.pe is een funktie die door de CCP Uitgevoerdinforl'\a.tie kan in de sYMbolta.ble gevonden worden.vQ,n een va,riQ,bele a.ts opera,nd voor een funktieworden, dlln !'loet de COP de sha,pe a,ts vector inschrijven.

'''IJrdt. Dezeflls de sha,pegebruikt I'\oet

de workspa.ce

Dez~ funkties Zijn da,ta.-dri.en functions die in principe welM~t de PFP gere~liseerd kunn~n ~orden, M~~r w~a,rvoor de~t90ritAen in een ~1geAene uitvoering a,~rdi9 cOAplex ~orden.

- 39-

funktie klolsse fUnktie kla.sse

select integers *Q.ssign index in ,.floor >Ir rll .... el ,.ceilin9 >Ir clltenllte lil

Ainil'lIJA >Ir 11ll'linQ.te >Ir

t'lllxi AUA •reverse *i.:hntitl:l 111 rot'lte ?

neg'lte *signul'l * tra.nspose *reCiproca.te .. perAute ?PI ol 9n i t IJ cl e * cOl'lpress >Ic

a.dd .. expllnd >Ir

slJbtra.ct *I'I IJltip 1':l * to.Ke ?divide • drop ?residlJe ,.

gra.de upbllse e power * gra.de downb'lse e log >Ir

power >Ir rol 1 >Ir

log >Ir delll

less * bllse .... a.lue '"not grea.ter >Ir represent '"equa.l *not less >Ir Alltrix i n'.. ersegr91lter • A'ltrix dil/ide'Jnequa.l 111

outer product *not >Ir inner pI'" od IJ .:t *a.nd >Ir

Ot' ... reduction ,..n'lnd * sCQ.n >Ic

nor *I'lerqbership '"pi tiAes >Ir subset >Ic

circ. fl.lnctions * superset *union ?

folctori'll >Ir intersection ?cOAbin'ltorilll >Ic exclusion ?

S'hllperesh'lpe '"

\

ta.b>aot 2.

- 40-

OM een Rot~te-sequence effectief in een ArC te iMple~enteren

Aoet er ep.n dlgoritMe gevonden worden dQt zo~el voor een scal~r

linkerQrqu~ent Qls voor een arrQ~ linkerarguAent Met een~iniMUM Q~n herinitiuiisaties de dQt,Q ophQalt. WUQrschijnlijkK~n het resultaat, van een rotate-operatie dan beter niet in eenRow Major Order gegenereerd worden.

PerAute kan naar Mijn Mening het beste tot een non data-drivenfunction getransforMeerd worden. Het AIC-algoritMe hiervoor hebik echter niet kunnen vinden.

TQ~e iS een funktie die zowel een COMpress Qls een expand overatle diMensies tegelijk tot gevolg heeft. Een QQnpuk OM dit ineen set PFP-QIgorit~en te realiseren heb ik niet kunnen vinden.Ee~ andere Mogelijkheid is de take-operQtie in Meerdere stappenuit te .oeren. Eerst over de eerste, dan over de tweede, .en tenslotte over de laatste diMensie.

Drop is eenvoudig in take te vertnlen.d:ln i s drop dc.t ook.

Als opgelost is,

Grade up/down zijn sorteeralgoritMen. D~ PFP k~n echter nietd~t~ in twee richtingen heen en weer schuiven. Wel k~n na desorteerbewerking de ~index ln~ fun~ti~ gebruikt worden, ~Q~r

het lijkt Mij effectiever een iota<~h~pe v~riab~le)-vector tevor~en Qls eerste resultaat en vervolgens ~erwisselingen in deobjectvector ook in dez~ ve~tor uit te vo~ren <alth~ns voor eenblJbble S'Ot't).

Deal

D ol a 1 koe. ntrekkinggeheugen

niet gei~pleMenteerd worden OMdatzonder terugleggen SiMuleert en

heeft O~ reeds getrokken wnarden te

deze funktie eende PFP '~ei?n lokoalkunnen bel,Hlt'en.

f1'ltt'ix invel"se/dil:lide

Deze funkties Moeten uit ~eerdere

worden, en kunnen d~o.roM nooit ineensworden.

APL-funkties opgebou~d

door de PFP geexecuteerd

- 41-

Het probleeM begint ~et de eis d~t ~lleen de unieke eleMentenin het uiteindelijke resultoat ~ogen voorkOMen. Voor union Moethet resylt~~t bijvoorbeeld opgebouwd ~orden uit een Qontaislagen dot gelijk iS Q~n de so~ van het ~Qnt~l eleMenten in Aen B. In de eerste slag wordt de cntenntion van A en 8 gevorMd.DadrnQ k~n het eerste eleMent v~n deze cQtenotion tot eersteeleMent VQn het resultQQt benoe"d worden. Het t~eede ele~ent

9Q~t deel uitMoken van het resultoQt als dit niet gelijk iS Qonhet eerste. Zo verdergQ~nd wordt er steeds een ete~ent VQn deeerste CQten~tion vergeleken Met het resyltuut zoals dat tot opdnt MOMent be5tQ~t en dit eleMent wordt Qun het result~Gt

toe ge ,ro e 9 ti Q 1ser ge en 0 I; ere enk 0 1'1 S t go? cr et e ld. e eo r d lol 0 r cl t .

In principe kunnen deze op~r~ties wei M~t de PFP gerealiseerdworden. In het Return DQt~ register stOQt don nn de funktie­uitvoering de lengte v~n de resultaatv~ctor. De AOC zoals diebeschrev~n is in parQgr~~f 5.4 Moet dan 5te~d5 voor ~~n dQt~­

eleMent geherinitial iseerd worden. Dit koMt doordat hetEleMent-Sequenc~-A190ritMede LAST ELEMEMT flipflop set en EOP­R ~evor~d wordt door de AHD-funktie v~n ftqueue eAptyU en LASTELEREHT, Maar de lengte van het result~Qt niet voorsp~id konworden. De HOC k~n daarOM bet~r Uitgebreid worden Met eenoperQtion-Mode 3 w~orin de d~tQqueue geleeogd, EOP-R geset enhet EleMent-Sequence-AlgoritMe gereset wordt. De AOC wordt dongeiniti~liseerd voor de ~~xiMale lengte van het resultaat.

De vraQg of Uni on, Intersection engeiMpleMenteerd dienen te worden wil

5.10 Geko.skadeerde PF?'s.

Setexclusion in de PFPik dan ook open laten.

De PFP zoo.ls die tot nu toe beh~ndeld is, werd gebrUikt OM eeneleMent~ire APL-oper~tie uit te voeren waQrbij ste~di eenresultQ~t in de V-workspace weggeschreven werd. Bij deuitvoering van een APL-expreSSie is het VQQk zo dat hetresultaat van een voorgoande oper~tie weer nIs operand voor eenvolgende operatie gebruikt dient te worden. Zo wordt R=A+B+C+OuitgeYerkt ~ls :

il=C+ Di2=B+ilR =A +i 2

- 42-

D~ resultaten Tl en T2 worden dus eerst weggeschr~ven en direktd~nrop wee~ gelezen ~ls op~r~nd. Oit k~n voorkoM~n worden ~ls

~r "~erdere k~skQdeerbqre PFpJ s in het systeeM Zijn. In dezeMogelijkheid wordt voorzien door een AOC/AIC OperQtion-Mode 2.In Mode 2 wordt het sign~ul SWITCH Qktief WQ~rMee een·schnkel~Qr· n~Qr de MeMory-dutQ-bus OMgezet kQn worden n~~r

een bus tussen twee n~Qst elkQur gelegen PFP's (rig.iO). Inriguur 9 is w~erge9~ven hoe d~ expressi~ A+B+C+D MetkQSKUdeerbure PFP's uitgevo~rd kun worden. De drieopt~loperQties verlopen nu voor een groot deel PQrQllel OMdQtde resultaten door-ripplen. Oe bufferw~rking VQn de AOC en deAIC-B dQtaqueues MQQkt d~t de ~eest tijdrovende bewerking nietdirect een bottle-neck gQut vorMen.

5. 10.1 D~ AOC/AIC OperQtion-Mode 2.

In Mode 2 hoeft een AOC!AIC geen Qdressen te berekenen. WelMoeten er eleMenten geteld worden oMd~t hi~rMee de PFCgesynchronise~rd wordt, Verder hoeft een van de twee geen"write U

respektie~elijk ftr~Qd"-signQlen .te genereren, OMdQt A?Lv~n rechts nQ~r links geev~lu~erd wordt, ligt het voor de h~nd

OM AIc-e d~ d~t~o~erdr~cht tussen de PFP's te IQten leiden. DeWR en de XACK v~n de AOC krijgen in Aode 2 dus ~en Qnderet~nktie. (WR wordt een (re~d) inputsign~~l en XRCK wordt nu ~~n

outputsign~~l). Het sign~~l S~ITCH is ~leen in Mode 2 aktief.

5.10.2 GebruiksAoge\ijkheden.

De gebruiksAogelijkheden van gekQskudeerd~ PFP's blijvenbeperkt tot die situnties w~urin het AIC-B Qt90rit~e van devolgende operatie gelij~ is aan het AOC algoritMe ~an devoorgaande operatie. Praktisch gesproken betekent dit,voertbouwend op de resultaten uit Qppendix B, dat dit het RowMajor Order QlgoritMe Mo~t Zijn. Wordt een expressie geschreven~ts;

<H> <M> <H) <M> <i>,

d~n M~g <T> iedere APL-fun~tie Zijn die het result~Qt

genere~rt. Dit Zijn Qlle gere~lise~rde runkties uitbehalve "represent u

•

in RMOtabel 2

- 43-

~ ol-t"

- !.r--

~ .. •

,

,40C

A

Piguur 9. Gekaskadeerde PFP' s .

" ","" ",

c

"""" "" """

Piguur 10. Kaskade-detai~.

- 44-

<M> Mag i@dere funktie zijn die het r@sult~at in RMO g@ner@ert@n bovendien via AIC-B data in RMO inleest. Een tweede eis dieaan <M> gesteld Moet worden is dat <M> een klasse 1 funktie uittab~l 1 (pragrQaf 5.7) Moet zijn. Hiertoe b~horen Metzekerheid:-Aonadic sCalQr priAitive functions.-inde;{ in.-ravel,cQtenate en lQAinQte.-expand.-sl..lperset.

Vuak behoren hiertoe ook dYQdiC scalar priAitive f~nctions,

echter er MQ9 geen diM@nsie gespecificeerd zijn. <Ook niet iM­pliciet, dl1t wil zeggen l'let A+B f'lQg ni@t A+[l'la~«Arankd3rQnk))a

b'i"do'i"ld worden.

<H> Aag ieder'i" funkti@ zijn die via AIC-B data in RMO inleest.Voor de funkties uit tabel 2 betekent dit dat <H> gelijk Qan<M> Moet Zijn.

De altijd geldige <H><M><T)-stryct~ren kunnen in de AAC herkendworden. Een T-l/ariQbeie in de COf'lpi l@r-outpIAt !'loet nu gel'lerktworden 01'1 QQn t@ geven dat het OA geKaskadeerde PFP's gaat. DeCOP kan naar niet per definitie geldige <H>{M><T)-structuren=oeken. (Twee OperQties vooruit interpreteren en steeds devoerlaatste stQrten). Het Maxi~Qle QuntQl Kuskndeerb~re PFP'sis een systeeMpar~Aeter.

- 45-

6. CON CLUS I ES.

In ~en effi~i~nte APL-M~chine Aoeten APL-operaties p~r~ll~l

g~interpr~teerd en geexecuteerd kunnen worden. Vervolgens ~oet

zo~el het interpreterproces ~ls het funktie-executieprocesgeoptinalis~erd worden.

Het interpreterproces k~n geoptiM~liseerd worden door ditproces op het niveQu van eleAent~ire oper~ties Met APL­v~riQbelen te laten plQntsvinden. HierMee kan in de runfnse~Qn prograM~a's de kortste interpretertijd per eleMent~ire

Oper'ltie gerealiseerd worden. Het logische gevolg hiervnn isd'lt er in de definitiefase vun APL een ·o/erreg~a.nde C()Mpila.tieViln de user-input plQats /'loet vinden. Er Moet nu ond~rzocht

worden of dit Mogelijk is zonder Qfbreuk te doen Q~n hetinter~ktieve ka.rakter van APL. Het na.deel Viln deze ~Qnp~k iS

da.t er Meer geheugenruiMte nodig iS (veel redund~nte

inforMatie).

In het in~erpreterpraces wordt ook geheugenruiMte aangevrQQgd~oor resulta.ten. Een efficient dynaAisch geheugenbeheer werktda.aroM eveneens positief op de interpretertijd per opera.tie. Ofh~t Ubuddy-systeel'l8 zOtlls voorgesteld in hoofdstuk 4 in APLvoldoende snel is en niet te veel workspace-reor9a.nisatiesintroduc~ert, znl even~ens nog onderzocht Moeten ~orden.

Het functie-executie proc~s in APL k~n geoptiM~liseerd wordendoor dQt~-prefetching. Dit wordt ~0gelijk als adresberekeningenv~n d~t~-eleMenten voor een funktie parallel ~a.n funktie­berekeningen uitgevoerd kunnen worden. In dit ~fstudeerwerk isd~ze aanptlK Uitgewerkt voor APL priMitive functions en -ope­r~tors. Voor scalar priMiti~e functions en priMitive operatorsis dit e'!"n goede aanpJlK gebl~ken. Hierbij I"loet wel dek~nttekening geplaQtst worden d~t de winst wa.arschiJnlijK p~s

Merkb~Qr ~ordt ~ls de operanden een, op dit MOMent nog nietwast te stellen, grootte bverschrijden. Voor dJlta-drivenfur.ctions Zijn de Mogelijkheden naar Mijn Mening Minderbevredigend, d~t wil zeggen I'let een PFP-strlJctuur zoals die inhoofdstl.lK 5 geschetst i os.

Voor de AOC en de ArC zie ik Meer algeMene toepa.ssings­Mogelijkheden, ook in andere prograMeertalen Metgestructureerde data-objecten, als deze bouwstenen ~ls

zelfst~ndige Modules in COMputersysteMen kunnen wordentoegepast. Deze Mogel ijkheden worden nog groter a.ls de dat~

direkt het Elel"lent-Sequencing-AlgoritMe v~n nieuwe pQr~Meters

k~n voorZien (data-driven ~ddress-sequences). Het selecterenv~n data in een bOOMstructuur kiln hierMee effectiever a~~gepQkt

ltJ·)rden.

- 46-

7. LITERATUUR.

(1] H. Kl],tzlln.APL ProgrQ~Aing ~nd

Co~pyt,er i~chniqu~s.

VQn HostrQnd Reinhold Co~pQny, 1~70.

[2] BurrolJghs.'APL/700 user reference ~QnuQl.

Burroughs Corporlltionl 1~77.

[33 DiktQat Besturingspr09rl],~AQt,uur 1.Collegediktnllt TH Eindhoven, 1~80.

C.H. VQn Hooidonk, IJ.W.M. Schepens.HQ.Qr de colleges VQn Ir. A.G.". G~urts.

- 47-

APPEHDIX Hl APLZSQ.

blz.

A. 1- De APLZSO l,}orl<spo.c~ 48A.1.l Indeling ~Gn de worksp~c~ ')" .48Al.2 Dl! s';.Il'Ibot to.b te 43A.l.3 Het da.t<lvetd : 52

A.2 Geh@ugenbeheer in APLZ80 57

- 48-

A.I D. APLZaO ~orksp~ce.

In de worksp~ce kunnen ~ier gebieden onderscheid~n worden.1)9%. Zijn: (zie fig A.U

1 >S~stel'lpl1rQ.l'let.rveld

2>SYl'lboltl1bleveld3>I)Qt~veld

4>Scr~tchp~dveld

RPI.. 2 ~r;I r/1If>A~E rERS

SYM'B(jL T"'~Lé

1),9 TA S Til. l/C rl/ ~ E $

- SYI1Bt'L TII8J.E - Er7EJVS'lbPS

- VI4RIA BLES

- FU"'~ T/()#S

f.- - - - - - - - - - -

FREé .s J-AC é

Sc RA TeN~ - - - - - - - - - -

P/f[)

.- BASEpo'IJrER

4-- ToF1'0111 TER

+-- INS TOP

Figuur A.l APLZ80 workspace.

- 4~-

Het p~r~~eterv@ld en het scr~tchp~dveld zullen nu kortbesproken worden. De sYMbolt~ble en het d~t~~eld zullen in~fzonderkijke p~rQ9rn~en ~~n de orde kOMen.

APLzeo iS een progr~Mft~ d~t in een CP/"-oMgeving dra~it. Deworksp~ceb~se is het adres 7000. Het ~dres v~n WS-top wordtgevonden op ~dres O~ (05 2 J"P BDOS). De ~a~rde ~S-top - 7DOO iseen diSplQceAent t.O.v. de WS-b~se en ~ls zod~nig een p~r~Aeter

in het p~r~AeterYeld, te noeAen TOP-pointer. E~n volgendep~r~Aeter die dan genoeAd dient te worden iS BASE-pointer.Even~ls TOP-pointer iS dit een displaceMent t.o.v.de ~S-b~se.

BASE-pointer en TOP-pointer begrenzen het vrije deel v~n hetdQtQveld. In een cleQr worksp~ce wijst BASE-pointer nQ~r deeerste vrije geheugenpl~Qts volgend op de sYMboltQble en TOP­pointer nQQr de WS-top.

Twee andere duidelijk te herkennen p~r~Meters

p~r~Meterveld zijn:- een pointer n~~r de inputbuffer.- sYAbolt~ble-size

Het scrQtch-p~d veld.

in het

Tijdens de executie VQn APL-st~teMents wordt de top v~n de ~s

QLS scrQtchpad gebruikt.Met iedere geheugen~lLoc~tie in de ws­top wordt TOP-pointer geModificeerd.

A.l.2 Oe sYAboltQble.

De sYMboltQble in APLZSO begint op ~dres 7DA4. Afh~nkelijk VQnde sYMbolt~ble-size ~orden hier 5*STS bytes voor gereserveerd.(STS=sYAbol-t~ble-size)

De sYAboltQble iS geschetst in Tig A.2. De entries in des~~bott~ble Zijn genUMMerd v~n 0 t/~ STS-l .Iedere ent,r~ best,Q~t

uit vijf bytes. De ~ier highorderbits in byte 1 gev~n een codewa~rAee Qangegeven wordt tot welke klQsse de identifierbehoort.Cvoor betekenis code Zie figuur). De vier loworderbitsin byte 1 geven het ~~ntQl karakters w~~ruit de identifiernQQAbesta~t. is deze lengte 1 of 2, dan worden de twe~ volgendebytes in besl~g genOMen door de identifiern~~M. Is de lengtegroter d~n 2, dan volgt een 2-bytes pointer n~Qr eensy~bolt~ble-extensie in het d~t~veld w~~r de identifiernaa~

- 50-

IIIII•

I I I I

TER DI'ITR.

F 2 eH MUlcTélfS •

IlO'"

'/.. F)

l. CCA l..S7lfClr .

E~

o - All I. 11 IJ IC rUA/CT'iJlII

I -to HtJN;f.OIC Ft/NC TI"'"

~ --. IJl/A IJle ':VNC r/~N

3 -. IIkT/E"E '''4~/.148EI.E

;-.. LE8E VA~Jlf1SE,E ., J.Hl!&'1.

F -"/'1kTIF"E Yt'f~/1'f8E"E h,U1FP'TAAAI,Pt:lIPTEIf III1UlIt GLoBIIL /)1971' t'P

••I

\"" V' ~ "'- "V'...;'

b L.. rD/~

IO'ENT/FIEIt NRI1E 1 ()

POl NTET( E:1tI71CY- Ex TEN

L...t> l E/tI6 rE ICE""TIF~E~NA hE élt.

4/1} rl FIER coDë

sTS -1

Piguur A.2 Symboltable.

NRHt 00

\ ...

COOl; vc:lon EAJTfi:.Y-EXTEIJSION

Figuur A.3 Datastructuren, Entry-extension.

- 51-

gespecificeerd wordt. D.z~ s~~bolt~ble-~xtensie kOMtbij d~ bespreking v~n het d~t~veld.

o. tw•• l~~tste bytes in i~d.re entry 9~ven een pointer n~~r dedata Qls het O~ een v~riabel~ gaGt, of een pointer na~r defunctionh~~d.r ~ls het O~ een runktie 9QQt. Voor vQriQbelen dieall •• n een lokale betekenis hebben iS deze pointer in nietakti9ve funkties 0000. Overigens, een pointer ~oet ook hierwe.r gezien worde" als een disptace~ent t.a v d~ WS-b~se.

Hu de opbouw VQn een sy~boltQble-entry

vraag: Hoe kOften we vanuit een nQQ"s~~bolt~ble. Het flowdiagrQ~ in figillustratie.

START

besprokennQQr eenA.4 dient

is! r °i j s t d eentrl~ in deh;erbi.j ter

t./NIT.VI'9(.:: EfII: .. (r. (AScrr)i.) ,..,00 STS,

y

EIJD.

5 Yf1 8tJl ­TRBlEFU/,/, •

Piguur A.4 Bashing flowdiagram.

- S2-

V~n ~en na~M, b~staande uit I k~r~kters ,worden de ASCII­w~~rden van de ~fzonderlijke k~rakters geSOMMeerd. V~n deze SOM

wordt ver~olgens de rest bij gehele del ing door sYMbolt~blesize

bepa~ld. Deze rest wordt het initiele entr~nUMMer in des~Mboltable. Is deze entr~ reeds bezet, (twee verschi tIenden~Men Kunnen dezelfde rest opleveren) d~n wordt een ~nder

kenMerk, het ~antal Karakters v~n die naaM in beschou~ing

genOMen. Het aant~l k~rakters 1 wordt opgeteld bij het initieleentrynuMAer (en eventueel wordt STS er van afgetrokken), waarnagekeken wordt of de nieuw berekende entry,vriJ is. Is dit ooknu niet het geval, dan wordt opnieuw I opgeteld. Dit g~at zoverder tot er of een vrije entry gevonden wordt, of hetentrynuAAer weer op z'n initiele waarde ter~9koAt. In dittQ~tste geval wordt de Melding nSYMBOLTABLE FULL u gegenereerd.Voerwaarde voor het goed functioneren van dit MechanisAe is deeis dat STS een prieMgetal Moet zijn.

A.l.2 Het dataveld.

Het dataveld volgt na de sYAboltable in de APLZ80-worKspace.Het bestaat uit een deet dat gevuld iS Met dQtastructuren eneen vrij deel dat begrensd wordt door de pointers BASE-pOinteren TOP-pOinter.

Met bet.rekking tot dat.astructuren kunnen de volgende typenonderscheiden worden:

1) entry-extensions2> v~riQbelen

3) funkrieregels

Iedere datastructuur begint ~et een uniforM vijf bytes veld dat~ls ~o19t iS opgebouwd.

<code> < point~r > < lengte >

In het eerste byte wordt het type datastructyur gecodeerd.Deze codes zijn:

02 entry extension14 variabele04 header user defined functionoe header ijSFHS-funktie00 reget in APL-funktie

- 53-

~e twee volgende bytes bev~tten een pointer (displ~ce~ent

t.o.v. ~s-b~se) die Wijst n~~r de d~t~structuur WQ~rin n~o.r denu beschouwde dQtQstructuur verwezen ~ordt. SYMboltable-entries~oeten nu a.ls speciale d~tastructuren geZien ~orden. Voor decodes 02, 14, 04 en oe wijst deze pointer teru9 nQ~r deo~ereenkoAstige sy~bolt~ble-entry. Yoor de code 00 wijst dezepointer no.Qr de voor~f9aa.nde APL-regel in dezelfde funktie.

De twee l~Qtste bytes in dit vijf byte veld geven de lengte v~n

de betret'fende da.ta.structuur. Opl'lerkelijk is nu do.t deze lengte~ltijd een !'leer is d~n de rUil'lte die ~et relev~nte inforMQtiege .... uld is.H@t lo.o.tste byte in iedere do.tQstrrJctuur iS no.MelijkQltijd 00. Yerl'loedelijk heeft dit te M~ken ~et het detecterenVQn h~rdwa.re-fouten die een systel'l-error-Metding tot gevolg/'loeten hebben.

In de figuren A.3, A.S en A.7 is dit vijf bytes veld duidelijkte herkennen.De figuren spreken verder voor zichzelf en in hetnlJ volgende wordt a.lleen n~der ingegQQn op funktie-definitie­d~tQstructuren.(fi9 A.7)

Ho. het uniforMe vijf bytes veld volgen twee twee-bytes velden.De eerste twee bytes geven een pointer .no.Qr de volqende regelin een bepQQlde userdefined (WSFNS)- funktie. De twee d~Q,rop

volgende bytes geven het regelnuAMer in BCD. In defunctionheQder is dit veld don't c~re. Oe functionheQder eniedere regel in een funktie worden dus o.ls Qfzonderlijkedo.to.structuren in de WS weggeschreven en Zijn door Middel vo.npointers Q,~n elkQQr gelinked.

H~t veld n~ de regelnuMMeridentific~tie representeertjnfOrM~tie die bij de desbetreffende regel hoort.(figb~sto.Qt in wezen Uit twee delen:

de APL­A.8) Het

1) Een COMpressed ASCII-veld. Hierin ligt de eigenlijkeinfor~~tie gecodeerd opgesl~gen.

2) Een veld wQo.rin boekhoudkundige inforM~tie betr~ffende hetcOMpressed-ASCII veld ligt opgeslagen.

Allereerst ZOoltoeg e l i cht.

nu het begrip

14

-54-

RHO ORTA

~2•

4 SHAPt' VEc.T01( (R/t",I<)t Z)

4 R "NI(

4 TYPEI!: --. BOOL FIUV

4'--+ I/tITE6ER.<1<] FJ.OItTINfi PCIN r~B (;KIIIl.IIC rER

4 I.EAJ(;T~

4 ~()'#JrER IV"".A ~"HlJoL TABLE·EIo/TItY

. 4 ~o()E VooR 'lARlABEL E

Figuur A.5 Datastructuren, Variabele.

----.....-v- ;/

'---- ---vr .J

L. MItAiTISsE 10 ()161

4 ExJ>OA/EJVr (ó BITS) G RoAJJ:)T~l. /0

4 j(6N é X "0 IJ 1: AJ r

1....+ I (; Al hAAIT

•L. PEe. 'F"olliT

T$ BCO

Figuur A.6 Integer en Floating Point datarepresentatie.

P1 -+

- 55-

~'f . p 1 Je x

" ~ (j p 2 ~tP Ir/)

;</ p 1 P 3 tifj 2?

~, 9; 3' I;p fJtJ ,; ~rI t,;

--.r--J --...,..-..." --...r--J --r--

L L~D(NT~L... R.E~E/. ,vuh,.,F,f Bce

po/~TFR ,JE.fT

'-liST

L EIJ6 rE4 COOE

iJ L, -+ Ft/Ne TIeN HFI1J)ë~

fJ tJ VERIJ()1.6 RE~EL'C LOCfCEO FI.INcr/()A) (wsFAlS)

I

Figuur A.7

I

Datastructuren, Defined function.

CONPRESSED Ifscrr.

-+ <:D ,: T ë R /1' N" rOr?

L....t> (j J : L. A CS EL IAJOIC ti TOR.

4 # FIELO$

4 LEN6'rE. "C.OMPRES:>EO Ascrr "- VELD.

Figuur A.S Gekodeerde regel APL.

- 56-

In ~en ~egel APL-tekst kunnen de volgende z~ken ond~rscheid~n

worden:1) S~l'Ibols (literClls)2) Oper~t~rs ZOClls + - ., \"IClar ook ch~rClcters als C ; (3) KonstQnt~n, in d~ tekst bestClQnde uit een of l'Ie~~

nUMeri~ke wQarden, booleans of char~cters. Een konst~nte

in tekst is dus hoogstens een vector.

AAP ~ 2 3 f HOOT + MIESe 3J

Sl~l'Ibo\s Zijn:Opera.tors zijn:Konstanten zijn:

AAP, ~'OOT,I1 lES~,., ,+,(,]

2 3 I 3

De afbeeldin~ van APL-tekst nQ,a.r cOl'lpressed ASCIIvolgt:

iS nlJ a.ls

E~n sYl'\bol wordt ve~va.ngen door twee \"10.0.1 d~ diSplQcel'lentt.o.v d~ sy~bo\tClble-bas~ VQn d~ o~ereenkoMstige entry in desYl'lbolta.ble.Voor ieder~ opera.tor bestQ.~t er een intern~ l-byte code. IncOl'lpressed ASCII wordt de nieuwe code t~ee M~a.l de oude(interne) cod~ + 1.Een konst~nte-veld wo~dt a.ls volgt gedefinieerd:< list Y~n konsta.nte-dQt~ )< ~Q.nta.l eleMenten><type>

ûe type-coderingen Zijn:

05 Boolea.n07 IntegerO~ Floa.ting PointOB Cha.ra.cter

Zo wordt: 2 35

00 00 02 00 00 03 02 0700 00 05 Ol 07

A~n het cOMpressed ASCII-veld gQ.a.t een veld va.n ~ier bytesvaora.f. ûe eerste twee bytes geven de lengte vOon het COMpressedASCII-veld. Oe da.a.rop volgende byte geeft de 501'\ VQn het ~a.nt~l

sYl'lool-, opera.tor- en konsta.nte-velden in het cOMpress~d ASCII­veld. De Qqa.rop volgende byte iS 03 ~ls de regel door een l~bel

voorQfgegQ~n ~ordt,. In ~lle Oondere geva.llen is deze byte Ol.

- 57-

D~ zin ~~n de even sYMbolrererenties en de oneven oper~tor­

konst~nte-rererenties blijkt uit het volgende:

M.b.v. de lengte v~n het co~pressed ~SCII-vel~ zet deinterpreter een pointer n~~r het eind vnn de runktieregel(rechts n~~r links ev~lu~tie). Vervolgens ~ordt getest or dezebyte even of oneven is. Is deze even, d~n iS er sprnke VQn eensYMbolreferentie en heeft de interpreter twee bytes nodig. Isdez& oneven, d~n is er .prake v~n een operator ch~rQcter ofkonst~ntereferentie. Bij een oper~torreferentie heeft deinterpreter nu· een byte nodig. Bij een konstQntereferentieberekent de interpreter uit het ~~nt~l eleMenten en het typeeen pointer n~~r het begin v~n het KonstQnte-veld. De type­coderingen (OS, 07, 09, OB ) even~ls de t~belindicator (Q3) ende terMin~tor <Ol) zijn nu te beschouwen QIs gereserveerdeoper~tor-codes.

A.2 Geheugenbeheer in APLZeO.

Geheugenbeheer in APL is dyn~Aisch. D.W.Z.geheugengebieden voor v~riQbelen ofgereserveerd worden. De volgende figurengeheugen-or9~nisntie-AechQnisMe:

A sCQt~r

e vectorC MatrixF funktie bestQQnde uit vijf regels.

dat er geen v~ste

funktiedeclQr~ties

i Ilustreren het

De workspace ziet er nu uit zo~ls geschetst in fig. A.~.l.

Vervolgens wordt sc~l~r A een vector A (fig A.~.2). HiernQwordt reg~l [3J in F v@r~ndert (fig A.9.3) en tenslotte gebeurt~r nog iets Met 8 (fig H.~.3).

Nieuwe d~t~structuren worden onder ~~n de 1 ijst geplQQtst.Indien een d~tastrYctuur verQnderd, dan wordt de oude dQtQverwiJderd,de d~~ronder gepl~~ste dQtQ schuift OMhoog ende nieuwe d4tQstructuur ~ordt onder QQn de lijsttoegevo~9d.

Dit MechQniS~e werkt si~pel en direkt,nogQI tijdrovend.

is in de run-fQse

A

B

C

F~

F1.

F2.

F3

Ft

FS'

1.=

8

c:.

F(J

Ft

FZ

F'f

F~

IT

P3

3.

- 58-

B

c

FtJ

FJ.

F2.

F3

Fit

F~

A

2.

c

FtP

F1

F2.

Fit

PS-

"F3

Ij

4.

Figuur A.9 Geheugenbeheer in APLZ80.

- 5~-

~PPENDIX B: PFP-ALGORITMEH.

B. 1 Inleid~nde Op~&rkingen. . , .B.2 Sc~l~r pri~itive functions , .

8.2.1 Mon~dic sCQt~r pri~itive functions,.8.2.2 DYQdiC sCQt~r pri~itive'functions.

8.3 Pri~itive operQtors. . ... ".8.3.1 Outer product,8.3.2 Reduction .B.3.3 ScQn .... , ..8.3.4 Inner product.

8.4 Mixed pri~iti~e functi~ns-sets..B. 4 . 1 MeAbers hip , .B.4.2 Subset, Superset .

B.S Mixed pri~iti~e functions-structure ..B.5.1 Resho.pe _ .8.5.2 Integersl Index in .8.5.3 RQ .... e1. Ca.ten'lte, LQ('IinQte.8.5.4 Rel/erse .8.5.5 Trl1nspose ..B.5.6 COPlpressl Exp~nd ..

B.E Mixed priAiti~& functions-other.8.6.1 Rolt. ..8.6.2 BQse vQlue, Represent .

blz.

60.61.61

I' .,· .. 0_

· .. 63.63.65.66.67.69.69.70.72.72.73

· .. 74" .77· . ,78

.79

.82

.82

.83

- 60-

8.1 Inleidende op~erkin~en.

In deze biJl~ge zal ~angegeven worden hoe APL pri~itiw~

functions en operators in de PFP geiApleAenteerd kunnen worden.Voor iedere gei~pleftenteerde funktie zullen de noodzakelijkeAOC, AIC en PFC-4lgoritMen Met de bijbehorende p~r~Aeters

beschre.en worden. Allereerst enige ~lgeftene opMerkingen:

OM par4Aeters voor een algoritAe te kunnen berekenen~oeten de rank en de sh~pe ~an zowel het re$ult4~t 415vQn de operanden bekend Zijn. De rank ~4n een vari4belewordt niet groter dan acht verondersteld.

In de APU-co""nnds MASpf(R.B)K en Rdspf(R,A.B)" ligt eencode voor de ge~enste scalaire operatie opgesloten. De~spf en de dspf-para"eters zijn een onderdeel vo.n deinitialisatie. Mao.r worden, even4ls KbQse", "type" enbMode M, niet e~pliciet 415 paraMeters genoeAd.

In PFP-41goritAen iS er n4ar gestreefd zcve~l ~oçeliJk

gebrUik te Aaken ~Qn parallelle reo.d/write-akties over deloco.l bus.

In Opero.ties w4arbij een vo.n de oper4nden een scalo.r ofeen single iS wordt deze operand slechts een "0.41 Uit deworkspace gelezen. (Behalve bij binner product U en "baseVQlu~u. In deze operaties wordt een sC4\arlsingle per.vector-inprodukt ge1ezen o"dat de algoritAen voor dealge"ene vor" anders te ingrijpend geWijZigd Moetenworden.

Oe PFP-~190ritften Zijn niet gedefinieerd voor lege do.t~­

objecten.

Als er in een funktie een di~ensie gespecificeerd wordt.dan wordt Index Origin 1 aangenOMen.

NUAerieke do.ta wordt re41-type verondersteld.

De procedure CALL ADORESS(eleAent) geeftrit~e o.an dQt voor dit eleMentnuA~er

read/write o.ktie gestQrt Moet worden.

in ieder 1l1go­een !.lIorl<spllce

- 61-

B.2 Sc~l~r pri~itive functions.

B.2.1 l'1onlldic sc~lQ1" pril'litive functions. (R'-I'lspf B)

Bij I'lon~dic sc~l~r pril'litive functions wordt A!C-Agebruikt. AIC-B en de AOC Roeten ~oor Row MQjorgeprogr~l'l~eerd worden. Het RMO-~lgoritl'le g~~t ~ts votgt:

A!C/AOC RMO:BEGIN eteAent:=-li

FOR count:=1 TO nUl'lber DOBEGIH elel'lent:=elel'lent + 1i

CALL ADDRESSCetel'lent)iE~D i

END.

nietOrder'

Het RMO-~lgoritMe heeft ~ts p~r~l'leter

berekening v~n nUl'lber iS ~ls volgt:

AIC/AOC RMO PAR:BEGIN nUAber:=l;I:=1;

WHILE I LEQ r~nk DOBEGIH nUl'lber:=nul'lber*shQpe(I]

1:=1+1;END;

END.

nu I'l be r nod i 9. De

De PFC Roet voorgeprogrQI'lMeerd worden.

Aon~dic sc~lnr pril'litive function:=;

PFC MSPF:BEGIN urelld (B,AIC-B)";

nl'lspf (R,B)";~HILE HOT EOP-B 00BEGIN "re~d (B,ÀIC-B),~rite (AOC,R)U

·",spf <R,B);END;"write (AOC,R)";WHILE HOT EOP-R DO nothing;ft interrupt ";

E ~l D.

Monndic sc~t~r pril'litive functions Zijnfunctions.

non

- 62-

8.2.2 Oyadic sc~lar pri~itive functions.

~oor dyedic scalQr pri~itive functions bestQan er twee vorMen:

1) R "4- A dspf S2) R"4-Çj dspfCKJ B

Voor de eerste vor~ Zijn de ~lgoritAen voor de beide A!C's ende AOC weer RMO-algorit~en. De initilllisQtie ven dezecontrollers iS dQn ook hetzelfde als bij de ~onQdiC scclllrpriAitive functions.

Het QlgoritA9 voor de PFè iS nu iets anders deer er rekeningMee gehouden ~oet worden dllt A of Been scalar of single is.Hiertoe wordt een pllra~eter READCOHTROL geintroduceerd. Dezeklln de l,IQarden 0,1,2 of 3 hebben.

READCOHTROL =0READCOHTROL =1READCOHTROL =2READCONTROL =3

Çj en B Zijn beiden sc~lQr of Single.A iS sClllQrlsingle en B niet.B is scalQrlsingle en A niet.A en B Zijn best~Qn beiden uit ~eer den eenelel'lent.

PFC.DSPF:BEGIN "read <A,ÇjIC-A), read <B,AIC-B)";

" dsp t'" <R ,. A , B ) n ;

WHILE HOT <EOP-A AHD EOP-B) DOBEGIH 00 CASE READCONTROL

0: i

t:"reed <B,AIC-B)' IJrite (AOC,R)U2:"reac! <A,AIC-A)' ""rite (AOC,R)"3:"re~d (ELAIC-A), re~d (BdIIC-B), ldt"'ite <AOC,R)"

"dspf <R.ILB)n;ENDi"'''rite (AOC,R)";WHILE HOT EOP-R DO nothing;"interrupt" ;

EH/).

De tldeede vorM van dyadic scalar pri~itive functions eist vooreen van de operanden een nieuld aclresberekenin9SQlgorit~e; HetCoerced Order algoritMe

- 63-

Arc co:·BEGIN ~t~l'\~nt :=-1i

FOR countl:=1 Ta rep1 DOBEGIN FOR count2:=1 Ta rep2 DO

BEGIN FOR count3: =1 TO rep3 DOBEGIN eleRent :=ele~ent+1i

CALL ADDRESS(ele~ent);

END;eleMent:=ele~ent-rep3;

END;eleAent:=eleMent+rep3i

EHD.

Dit ~l~critMe eist drie p~r~Meters en Aoet to~gep~$t ~orden

voor de oper~nd Met het kleinste ~~nt~l elel'\enten. Dep~r~~eters worden Uit de $h~p~ v~n het result~~t berekend.

AIC CO PAR:BEGIN IF K=1 THEH rep1 :=1

ELSE rep 1: =rshu.pe[ 1J* ... *r:ih~perK-1 1;rep;2: =r$h~pe[Kl;IF K=rr~nk THEH rep3:=1

ELSE rep3: =rshllpeC K+1 1* ... *rsh~per I'rllnk liEND.

H~t PFC-~lgorit~e k~n voor deze tweede vorM ongeWijZigdblijVen. Dy~dic sc~lllr priMitive functions Zijn non d~t~-driven

functions.

B.3 PriMitive operdtors.

8.3.1 Out!?!' product. (R~A o.dspf B)

AIC-A k~n wederoA voor RMO gepro9r~MMeerd worden. Voor ArC-BMeet er nu een gegener~liseerd RMO-1l1goritMe ingevoerd worden.Operu.ncl B Moet nu Meerdere ~Illen in RMO worden opgeh~~td. HetjUiste û~nta.t iS gelijk u.u.n het u.u.nta.l d~tu.-eleAenten inopertlnd A.

- 64-

AIC-B GRI'lO:BEGIN FQR count1: =1 TO r~p DO

BEGIN ele~ent~=-lj

FOR count2:=1 TO nu~ber DOBEGIN eleMent:=ele~ent~lj

CALL ADDRESS(eleMent)jEND j

END;END.

Het GRMO heeft dus behGlve de p~rG"eter nu~ber nog een tweedep~r~Meter <rep) nodig.

AIC-B GRI10 PAR:BEGIN bnul'lber:=l;I:=lj

WHILE I LEQ br~nk DOBEGIN bnuftber:=bnuMber*bshGpe[ I]

I:=I~li

END;rep:=1jI:=t;WHILE I LEQ ~r~nk DOBEGIN rep:=rep.Gsh~pe[I]

I:=I~t;

ENDjEND.

Het PFC-Glgorit~e voor outer-product luidt ~ls ~olgt:

PFC GUTP:BEGIN WH!LE HOT (EOP-A AND EOP-B) DO

BEG IN Ut~eGd( A, A I C-A) j re'ld< S, AI C-8)· j

Udspf(RdLB)"jcount:=1;WHILE count LEG rep-l DOBEGIN UreGd( 8dIIC-B)j "wr i te(AOC, R)D j

"dspf<R,A,B)"jcount: =count~1;

Etl 0;ENDj"IIirite(AOC,R)"jYHILE HOT EOP-R DO nothing;"interrupt";

END.

ûe p~r~Aeter rep iS dezelfde Gis in de initi~lisatie voor hetGRMO-algoritMe voer AIC-B. Outer product iS een non datG-driVenfunction. Een uitprodukt WGGrin een vGn de operGnden een sc~lGr

of een single iS ~oet ~ls dYGdiC sc~lGr priMitive functionbehandeld worden.

- 65-

8.3.2 Reduction (R--dspt'ICKJ B ).

Voo~ de AOC wordt het RMO-~t~o~it~e ~ekozen. Het~dresbe~ekenin~s~tgc~it~e v~n AIC-B wo~dt hie~aan ~~ngep~st.

Yoo~ AIC-B wordt nu het reduction-atgo~it~e ingevoerd.

AIC-B RED:BEGIN ete~ent:=rep2*rep3i

FOR countl: =1 TO ~ep 1 DOBEGIN FOR count2:=1 TO ~ep2 DO

BEGIN FOR count3:=1 TO rep3 DOBEGIN ete~Qnt:=ele"ent-rep2i

CALL ADDRESS(eleAent)iENDieleMent:=eleAent.rep2*~ep3.1;

END;ele~ent:=ele"ent.rep2*rep3-~ep2;

END;END.

Het algo~itI'U~ l'la~kt gebruik van drie pOoral'\eters: repL rep2 enrep3. De berekening vÜ.n deze pa.rOol'leters.is Ools volgt:

RED PAR:IF K=1 THEN

ELSEIF K=brank

AIC-SBEGIN

END

repl:=1rep 1 : =bsh~pe( 1 J* ... *bsh~peCK-l J;THEN l'ep2:=1ELSE rep2: =bshOopeC K+l J* ... >llbsha.per br'ln1< J;

rep3: =bsho.peC KJ;

Het ü.lgoritl'le geeft geen gedefinieerd result~~t voor 8 sca.ta.r.Hoewel het atgoritl'\Q wel goed go.Oot voor 8 single iS het nogo.lOl'\sta.Chtig een reduktie op een single Met dit a.lgoritMe uit t~

voeren.

- 66-

Het PFC-~lgoritAe voor reduktie luidt ~ls volgt:

PFC RED:BEGIN WHILE HOT EOP-B DO

BEGIN ·read(B.AIC-B)~

count :=1;WHILE count LEG rep3-1 DOBEGIN ·re~d<A.AIC-B)·;

-dspf<S.A,B)";count:=count+l;

EH D;·write(AOC,B)" ;

END;WH!LE HOT EOP-R DO nothingi"interrupt";

END.

Het ~tgorit~e gebruikt ~ls parä~eter eveneens rep3.zelfde ~ts uit de AIC-B initialisatie. Reduction is

een non d~t~-driven function.

B.3.3 Se~n <R+-dspf \ Uc1 BL

De AOC k~n wedero~ voor R"O gepro9r~~~eerd worden.wordt nu het sc~n-QlgoritAe ingevoerd.

AIC-B SCAN:BEGIN first:=rep3;

FOR countl:=! TO rep! DOBEGIN FOR count2:=1 TO rep2 DO

BEGIN FOR count3:=! ra rep3 DOBEGIN ele~ent:=firstj

FOR count4:=1 ro count2 DO8EGIN eteMent:=ele~ent-r~p3;

CALL ADDRESS(eleMent);END;first:=first+lj

END;Etl Dj

EHO;EHD.

Dit iS deook ltJeer

Voor AIC-B

Het ~tgorit~e gebruikt weer drie p~r~Meters. Dit Zijn dezelfde~ts bij reduction, ~lleen hebben rep2 en rep3 v~n pl~Qts

,~el&l i SS!? td.

- 6'7-

AIC-B SCAN PAR:BEGIN IF K=l THEH ~epl:=l

ELSE ~ep 1: =bsha.pe[ 1 H ... *bsha.pe( K-l];rep2: =bsha.pe( KJ;IF K=bra.nk THEN r~p3:=1

ELSE rep3:=bsha.peCK+IJ* ... *bsha.pe(bra.nkJ;END

PFC SCAN:BEGIN WHILE HOT EOP-B DO

FOR countl:=l Ta rep2 00BEGIN FOR count2:=1 TO rep3 00

BEGIN "I'ea.d( BdHC-8 )a;

count3:=1;WHILE count3 LEQ countl-l DOBEGIN area.d(A,AIC-B)";

"dspf'(B,A,B)";count3:=count3+1:

END;"write<AOt,B)":

END;END;WHILE NOT EOP-R DO nothing;11 interrupt";

HID.

Het PFC SCAN a.lgorit~e gebruikt a.ls pQ.ra.~ete~s rep2 en rep3.Rep2 en rep3 Zijn weer dezelf'de pa.ra.Aeters a.ls uit de AIC-Binitia.lisa.tie. SCAN iS een non da.ta.-driven f'unction. Evena.lsbij reduction is het _scQ.n-a.190rit~e niet gedefinieerd voor Bsca.la.,' en werkt het wel I,'oor B Single, AQ.Q.~ is het hier niet1/1)01' bedoeld.

8.3.4 Inner p,'oduct (R04-A dspf1.dspf'2 B).

Oe AOe wordt voor R~O gepro9rQ.A~eerd en de AIC-a.lgoritMenworden hiera.a.n a.Qnçepa.st.

- 68-

AIC-A lP:BEGIN ete~ent:=rep3j

FOR countl:=l TD r~pl 00BEGIN FOR count2:=1 Ta rep2 DO

BEGIN FOP. count3:=1 TO rep3 00BEGIN ele~ent :=ele~ent-lj

CALL ADDRESS(el~~ent):

END;eleAent:=ete~ent+rep3;

END j

ele~ent:=ele~ent+rep3;

END;END.

AIC-A lP PAR:BEGIN ~epl:=~sh~pe[l]* ..

~ep2:=bsh~pe[2]*..~ep3:=~sh~pe(~~dnkl;

END.

. .• ~sh(lI:')e[ ~r(lnk-ll i

. .*bsha.pe[ bro.nk] i

AIC-B lP:BEGIN FOR countl:=l TO repl DO

BEGIN ele~ent:=rep2*~ep3i

FOR count2:=1 Ta rep2 DOBEGIN FOP. count3:=1 Ta rep3 00

BEGIN ete"ent:=ele~ent-rep2i

CALL AODRESS(~le~ent);

END;eleRent:=ele~ent+rep2*rep3+1:

END;END;

END.

BEGIN repl: =~sha.pe[ 11* ..~ep2:=bshQ.pe[2]*..rep3: =bshdpe( 1 U

END ..

..Q.shQ.pe[Q.r~nk-l];

.*bshCLpe(b~Q.nk]j

.·R~pl en rep2 Zijn in de AIC-A en de AIC-B initi'llisa.tie gelijl<.Bij de pa.rQ.~~terberekeningen ~oeten de ~olgende punten in dchtgenoAen ~orden: )

-E~n vector A ~ordt beha.ndeld o.ls ~en ~dtrix A Met sha.pel,rho A en r~nk 2.

-Een vector B wordt behdndeld ~ls een Aatrix B Met sho.per ho BIl en r~ nk 2.

-Een sc~lar A or B wordt behandeld als een single ~et ra.nk2 (d e sh a peis 1, 1 ).

- 6~-

H~t PFC-~l~orit~e eist weer een READCOHTROL-p~r~~eter:

REÁDCONTROL=QREP.DCONTROL=lREÁDCONTROL=2READCOtHROL=3

Clsh~pe(~I"'~nl(l=l en bsha.pe[ 11=1Clshllpe(a./"C1nk1=1 en bshO,pe[ 1 J HEG 1ClshC1pe[ a./"a.nl< J NEQ 1 en bshC1pe[ 11= 1Clsh~pe(Q.r~nk1 HEG 1 en bshClpeC11 NEQ 1

PFC lP:BEGIH WHILE Hor (EOP-A AHD EOP-B) 00

BEGIH -reC1d(A,AIC-A);relld(B,AIC-B)";"dspf2( R, A, B)";count :=1;WHILE count LEG rep-l DOBEGIN DO CASE REAOCONTROL

o ~ ;1: "rea.d< B,AIC-B)";2:"l"'eQ.d<A,AIC-A)";3:"rea.d(A,AIC-A);rea.d(B,AIC-B)";-dspf2(0,A,B)";"dspf1CR,ILR)";count:=count+1;

EHD i"l4riteCAOC,R)";

END;WHILE HOT EOP-R DO nothingJ"interrupt"

EHD.

Behalve REAOCONTROL kent het a.190rit~e nog de pa.ra.~eter rep:

PFC lP PAR: /"ep:=MAXCa.sha.pe[~ra.nk1,bsh~pe[1J);

8.4 Mix~d pri~itive functions - sets.

8.4.1 Mel'lbership C R-+-AeB).

De Mel'lbership-operatie iS a.lleen zinvol ~et de PFP te verwerken~ls A en 8 een gelijk type hebben. In het a.ndere gevQ.I(verschillend type) Aoet de COP voor het result~a.t een nu~eriek

dQ.tQ.-object !'let ra.nk en sha.pe va.n A geheel gevuld Met 0 in deworkspa.ce creeren. Bij de bespreking va.n de resha.pe-funktiewordt hiervoor een speciQ.le FILL-funktie gedefinieerd. Zo'nF!LL-runkti~ heeft voordeel als het O~ grote d~tQ.-objecten

g~a.t. Het nu volgende a.lgoritMe gaa.t Uit vlln een gelijK typeVil!". A en B.

- 70-

De AOC en AIC-A ~arden geinitinliseerd voor RMO. AIC-B wordtvoor GRMO ~et de p~r~~eter rep gel ijk ~dn ~nu~ber

geiniti~liseerd. Me~bership iS een voorbeeld v~n een dat~­

driven tunet ion. De herinitialisatie v~n AIC-a bestd~t uit eenreset Vdn het GRMO-dlgorit~e.

PFC MEMBERSHIP:BEGIN WHILE HOT EOP-A 00

BEGIN QreadCAIAIC-A)";"zero-loa.d R";count:=1;continue:=TRIJE;WHILE count LEG bnu~ber AND continue DOBEGIN "readCB,AIC-B)·;

·coMpareCflag.AJB)";WHILE NOT EOP-APU DO nothing;IF fta.gTHEN BEGIN ·one-Ioa.d R";

continue:=FALSE;EHD;

ELSE count:=count+l;E~I D;"writeCAOC.R)";

EHDiCALL RESET;WHILE HOT EOP-R DO nothing;" interrupt";

END.

RESET: "write (AIC-B. unit reset)";

De pdrdAeter bnuAber is dezelfde als uit de AIC-Binitidlisa.tie. De da.ta v~n oper~nd B wordt cyclisch voorvergelijking gebruikt OM een beter rende~ent van de AIC-Bdataqueue te bewerkstelligen. (~en rest~rt van een AIC-B RMOalgoritMe na. een Match ZOU bete~enen ddt reeds opgeha.Q.lde d~tQ.

weggegooid zou Moeten worden.) In het onwQ.a.rschijnlijke gevdlddt B een sCQ.I~r of een single is, ka.n beter de dya.diC 5cdla.rpriAitive functiO" Requa.l- gebruikt worden.

8.4.2 Subset <R+- AcB) en superset (R+- À':) El).

Ook hier wordt het triviQI~ geval da.t A en B verschillend typehebben ni~t Gis PFP-funktie beh~ndeld. De cop z~l in dit geval~~n h~t result~~t de scalar 0 toekennen. Supset iS even~ls

~~Mber~hip een data.-driven tunetion. Het PFC-algoritMe vertoontveel gelijkeniS ~et het algoritMe voor ~~Mbershipl M~ar bevat

- 71-

een uitbreiding die de beide ArC's een tot~le reset geeft ~ls

een eleAent v~n A niet in B Yoorko~t en de funktie-uitvoeringbeeindiQd kan wc~den. De AOC en AIC-A worden weer voor RMO.AIC-8 wordt weer ~oor GRMO (Aet rep=~nuAber) geprogr~AAeerd.

PFC SUBSET:BEGIN a one lo~d RU;

WHILE HOT EOP-A DOBEGIH Ure~d(A.AIC-A)";

co un t : =1;continue:=TRUEiWHILE count LEQ bnuMber AND continue DOBEGIN ·~ead(B.AIC-B)U;

·coAp~re(fl~g.A.B)·;

WHILE HOT EOP-APU DO nothingiIF fl~9

THEH continue:=FALSE;ELSE count:=count+1i

EH D;IF continue=TRUE THEHBEGIN CALL RESET;

"zero-Io~d RU;EH D;

END;"write(AOC.R)";WHILE HOT EOP-R DO nothing;• interrupt";

END.

RESET:8EGIN ·write(AIC-A.unit reset)·;"write(AIC-B.unit reset)";

END.

In de swbset-~lgoritAen Zijn geen A~atregelen geno~en voor desitu~tie d~t B een sc~t~r of een single iS en A uit ~eer duneen eleMent best~~t. Deze situatie geeft ~lleen een result~~t 1llis ~lle elel'lenten lIan A"gelijk Zijn en dit tevens de lJao.rdeViln B is. Het ~lgoritl'le werl<t in deze sïtuatie wel goed. 1'I~~r

iS yeinig efficient OAd~t het enige eleAent lI~n B dan steedsopnieuw uit het geheugen gelezen gAat worden. In de situ~tie

do.t A en B beiden uit een eleMent bestaan werkt h~t a190rit~e

001<. t\~'lt" de "equQ.l"-opero.tie iS sneller. Een ander Jlltet'n~tiet'

iS dJln de COP zorg te l~ten dr~gen 11001' de uitvoering.

Superset iS niets anders d~n subset wQ.Jlrbij de oper~nden

verwisseld Zijn. Superset wordt d~~ro~ niet ap~rt behandeld.

- 72-

8.5 MiX~d pri~iti~e functions-structure.

Resh~pe iS in principe een d~t~-driYen function, ~~~r o~d~t deCOP toch geheugenrui~te ~oor het r.sult~~t ~oet ~~nYrQgen, iSdeze funktie eenvoudig tot non d~t~-driYen t~ tr~nsforMeren. Dp.COP leest d~~rtoe de d~t~ v~n A uit de worksp~ce en controleertof dit een niet ne9~tie'tJe intl?ger vector of single iS. De COPberekent nu het ~~nt~l eleMenten in het resultd~t: rnu~ber. DeAOC wordt d~n voor RMO gepro9r~MAeerd. In het ~lgeMeen z~l het~dnt~l eleAenten w~~ruit het result~~t z~l 9~~n besta~n nietgelijk Zijn ~~n het a~ntal eleAenten v~n B (bnuMber). AlC-A enAIC~S worden nu beide gebruikt. De b~se- en typep~ra~eters vanArC-AIS Zijn gelijk. AlC-B wordt vervolgens voor GRMOgeprogr~AMeerd en ArC-A voor RMO. De AlC-A/B par~Meters Zijnnu:

ArC-A/B RESHAPE PAR:BEGIN bnuMber:=bshape(11* *bshape(br~nkl;

rep:=rnu~ber Drv bnUAber;anuMber:=rnu~ber MOO bnuMberi

OID.

Bij deze paraMeterberekening Mag dnuMber echter niet nul ~orden

daar dan het R~O-a190ritMe niet gedefinieerd is. Het PFC­algoritMe iS ~ls volgt:

PFC RESHAPE:BEGIN "read(B.AlC-B)D

"trilnsfer(R,B)UWH!LE HOT EOP-B DOBEGIN Dr~ad(B.AIC-B~;~rit~CAOC.R)U;

Utra.nsf'erCR,B)";END;WHILE HOT EOP-Ä DOBEGIH "readCA.AIC-A);writeCAOC.R)U;

-tt'ansfer( R. A)";END;"writeCAOC.R)";WHILE HOT EOP-R DO nothing;.. i nterrr.lpt ";

END.

Als 8 een scal~r of een singl~ iS kan de hier te presenterenFILL-funktîl? gebrUikt ~orden. Hiertoe wordt er in d~ ~orkspQce

ee~ fi ll-ete~~nt aangewezen dat ~ia AIC-B gelezen en via de AOeeen ~~ntQl ~dlen in de work$PQce weggeschreven wordt.

- 73-

PFC FILL:BEGIN "~e~d(R,AIC-B)"i

WH!LE NOT EOP-R DO "w~ite(AOC,R)")

"inter'r'upt"iEHD.

In het ~1ge~een z~l dit ~190ritAe te veel dat~ na~r de AOeSChrijven, doch deze wordt niet in de ~orksp~ce geschreveno~d~t de AOC het adnt~l ele~enten telt.

8.5.2 Integer's, rndel( in.

!ntegers iS ook weer een eenvoudig tot non d~ta-dr:ven tetransforMeren funktie. De AIe's hoeven zelfs niet gebruikt teworden. De COP leest e uit de worksp~ce en prograMMeerd de AOC11001' RMO.

PFC HH;BEGIH "tr~nsrer(R,IO»)

WHILE HOT EOP-R 00BEGIH "write(AOC,R)")

"incl"el'lent<R)")END;" i t1terrupt")

E ~t 0 .

tt1dex il1 (R+- A'\. S).

De AOe et1 RIC-S worden voor RMO, AIC-A wordt voor GR~O (Met repgelijk Q.Q.n bnul'lber) gepro9r~I'lMeo?rd. Index in iS een data-drillenfunction die veel overeen~oMst vertoont Met MeMbership.

- 74-

PFC !NDEX !N:BEGIN ul O •l d(DJ-l)U

UHILE NOT EOP-B DOBEGIN are~d(BJA!C-B)a;

count :=1;continue:=TRUE;WHILE count LEQ ~nuMber AHD continue DOBEGIN ·re~d(AJAIC-A)a;

·col'\p~re( flllg J fL B) u;

0:=(0+1) MOD ~nu~ber;

WHILE MOT EOP-APU DO nothingiIF t' l~g

THEN BEGIN continue:=FALSE;R; =D i

END:ELSE CO'Jnt :=count+1;

END;IF cantinue=TRUE THEN R:=llnUMber;R:=R+IO;a I" rit e( A0 C J R ) R ;

ENDiCALL RESET;WHILE HOT EOP-R DO nothingiu interr'Jpt"';

ENO.

RESET:

In een APL-e~pressie iS de r~vel-oper~tie v~Qk een nul-aperlltieQM~Qt de d~tQ-elel'\enten s\~ndnürd in RMO in het geheugen staan.Als het resultll~t expliciet üQn een ündere variabele wordttoege~ezen. d4n ~cet B gekopieerd warden. De AOC- en A!C-BBlgorit~en hiervoor zijn zo eenvoudig dat een besprekingüchter~ege klln blijVen.

Voer geoorloofde cütenQt.-oper~ties Zijn er drie Aogelijkheden:1 ~1 'l t' 'l r' k =b r Q n k (I~ r .j t -? t' .::\ r gel î .j I< a'l n 1).:2 ;. A8S ( 'l("l n k - b t' Q. tü< ) =1 .3) A an!or 8 is e~n sCQIBr of single.D~ ~C~ ~~, j~ beide AIe/s word~n voor RMO g@progrnMAeerd.

•

- 7S-

H~t PFC-c~tenate algoritAe lUidt ~ls ~Qlgt:

PFC CAT:BEGIN DO CASE READCOHTROL

O:8ECIN "re~d(A,AIC-A),read(B,AIC-B)U;

"wrlte(AOC,R )Ui

"write(AOC,B)";EN!)i

1: "rea.d( AdHC-A) u i

2: "r~lld< B, AIC-B )"i3 : ;WHILE NOT <EOP-A AND EOP-B) DOBEGIN DO CASE REAOCOHTROL

0; i

1 : i

2: "reo.dUL AIC-A)" i3: "rea.dUl, lUC-A)";"tl'~t1st'er(R, A)" l

count:=l;~HILE count < 4ti~es DOBEGIN 00 CASE READCONTROL

0: i

1: "wri tee AOC, R)";2 : " rea. d ( A, A IC - A ) ; lol rit e <- A0 C IR) ti i

3:"rea.d(A,AIC-A);write(AOC,R)"i"tro.nst'er(Rdl)Uicount:=count+li

END;"write(AOC,R)"iDO CASE READCOHTROLO• •, ,1 : ure a.d ( B , AIC - B )" i

3: "rea.d(A/AIC-A)" i"tl'~nsrer( R, B)" i

count.:=liI.IIH ILE count <- bt i ~es 00BEGIN DO case READCOHTROL

0: ;1: Area.d( BdUC-B)iwr ite( AOC,R )U;

2: u write(AOC,R)";3:"r~Q.d(B,AIC-B)iwrite(AOC,R)";

IItra.nst'er(R,B)";count:=count+-li

EN D;"write(AOC,R)1/

E~Di

~HrLE NOT EOP-R DO nothingiu interrupt" i

EHD.

- 76-

READCONTROL geeft we~r de sc~t~rISin91e, niet sc~l~r/Sin91e

co~binlties vIn A en B weer. D~ p~rl~eters ati~es en bti~es

worden ~ls ~olgt berekend.

PFC CAT PAR:BEGIN ~ti~es:=lshlpeCK]* ..

bti~es:=bsh~peCK]*..END.

. Q.sh~peC Ir~nl(].

. bshapeC brllnk].

Voordat d~:e berekening uit~evoerd Mag worden ~oet er voor deAogelijkheden 2) en 3) een correctie toegepIst ~orden op desh~pe vlln een v~n de varilbelen. Als de ene operllnd een r~nk

heeft die 1 kleiner iS dIn de Ilndere, dlln worden de rInksgelijk geAallkt door in de shllpe van het kleiner-rInk IlrrllY een1 in te vullen op de plllllts vlln diMensie K. bijVOorbeeld:

A=2 3 5 rhoB= 2 S rho

iota. 30iata. 10

~oor de c~tenation A,C2JS wordt operand B nu beschouwd ~ls eenarray Met rllnk 3 en shllpe 2 1 5.

Als Been sca.la.r of een Single zou Zijn'geweest, bijVOorbeeld 5dan werd deze 'konst~nte voor een clltenltion over de eerstedi~ensie beschouwd dts een Ilrro.y Met rllnk 3 en shape 1 3 5. Inde plrdMeter READCOHTROL ~oet B echter wel Ils sc~lQ.rlsingle

~Q.ngegeven worden.

Als A en B beiden sca.lllrisingle Zijn, ~oeten zeeleMent ve·:toren beschouwd woorden (ra.nL<=shlpe=l).

Ills single-

L~~in~te ~ordt beschreven dls Rd~t de nieuwe diAensie voor(VK=ceiling 1»

FLCVK1B 1"lQ./lt'in'v'K g!ö'injecteet'cJ

VK betel<ent~'uet wOt'den.

De AOC en de beide AIC' s wo~den weer voo~ RMO geprugr~AReerd.

Voer lQAina.te kan hetzelfde PFC-a.lgoritRe a.ls vaar cQ,tenate1ebruikt worden Aet pa.raAeters:

PFC LAM PAR:BEGIN IF a.~Q.nk > brank

THEN a.tiAes:=btiAes:=asha.peCYKl*.ELSE IltiMes:=btiMes:=bsh~pe(VKl*.

END

. . :teQ.shllpe( tlra.nL< 1" *bsh~peC bt'olnl<: 1

Ook deCa. t~H\'l te

polra.Aeter READCOHTRûL iS hier va.n toepolssing.~n LtlMina.te Zijn non dolta.-driven functions.

Rüvel,

- 77-

B.5.4 Revel"se (R+-~(K] B).

De AOe ~ordt ~oor RMO gepro9r~R~eerd en het ~190ritM~ voor Ale­a wordt hiel"~~n ~~ngep~st. Reverse iS een non ddt~-dl"iven

t'unction.

AlC RE":BEGIN eleMent:=rep2*(rep3-1 )-1;

FOR countl: =1 ro rep! DOBEGlH FOR count2:=t TO l"ep2 DO

BEGIN FOR count3:=1 TO rep3 DOBEGIN eleMent:=eleMent+li

eALL AODRESSCeleAent)iEHDieleMent:=eleMent-2*rep3i

END;eleAent:=eleMent+2*l"ep2*rep3i

END;.END.

Het ~l90rÎtMe M~~kt gebruik v~n drie p~r~Meters: repl, rep2 enI" e p 3. 0 e be rek en i n.9 v ~ n de z e p~ I" Q.l'l et ers . i s c. 1S 'rI 0 19 t :

AIC-BBEGIN

END

RE" PAR:IF K=l THEH rep1:=1

ELSE rep1 :=bsh~pe[ t ]* ... *bsh~pe[K-t];" ep 2 : =b s h~ Pe [ K ] iIF K=br~nk THEN rep3:=1

ELSE rep3 :.=bshtlpe[ K+l]* ... *bsha.peC br'lnk]i

Het PFe-~190ritAe voor revers~l geeft Q.l1e~n d~tQ. v~n AlC-Bdoor n~Q.r de AOe en luidt:

PFC REVERSE:BEGIN "rellde B. AIC-B)" j

n tra.nsi'er( R, B)n;WHILE HOT EOP-B DDBEGIN "reQ.d(B.AIC-8):~riteCAOCJR)n:

"tra.nsferCR,8)":END;"write(AOC,R)"~HILE NOT EOP-R DO nothing;"interrupt";

END.

- 78-

8.5.5 Tr~nspo~e (R+- ~ B).

rr~nspos~ iS een runkti~ w~~rbiJ het ~~nt~l AIC-B pQr~~~t~rs

line~ir toenee~t ~et de A~xiMu~l toeqest~ne r~nk voorvQ~i~belen. Voor de ROC wordt h~t RMO-algoritMe gekozen en voorAIC-B wc~dt nu het Tr~nspose-~lgo~it~e ingevoerd.

ArC-B TRAHSPOSE:BEGIN ele~ent:=-step[8]j

FOR .:ount 1: =1 TO rshape[ 1] DOBEGIN FOR count2:=1 Ta rsh~peC2] DO

BEG!N FOR count3:=1 TO rsh~pe[3] 00BEGIN FOR count4:=1 TO rsh~peC4] DO

BEGIN FOR count5:=1 TO rsh~peC5] DOBEGIN FOR count6:=1 TO rsh~pe[6] DO

BEGIN FOR count7:=1 Ta rsh~peC7] DOBEGIN FOR count8:=1 TO rsh~peC8] DO

BEGIN eleAent:=elenent+stepC8];CALL ADDRESS(ele~ent);

END)elenent:=eleMent-stepC9]+stepC7])

EHD) .eleAent:=eleAent-stepC8]+stepC6])

END)eleMent:=el~~ent-stepC7]+stepC5];

EHD;ele~ent:=eleAent-step[6]+stepC4])

EH DJeleMent:=eleAent-stepC5]+stepC3])

EHD;eleAent:=eleMent-stepC4]+st~pC2])

END)~lenent: =elel'\ent-stepC3 ]+stepC 1];

EHD)END;

1/001' de b~rekenin9 .... o.n pQ,r~l'leters wordt uitgeglliln \I il n de sho.peVoln het result~llt, links o.~ngevuld !'let -enen A

• Voorbeelden:

Als bsh~pe=2 3 4 dQn wordt rshQ.p~ 1 1 1 1 1 4 3 ....:.

Als bshllp~= 5 6 dlln wordt rsh~p ... 1 1 1 1 1 1 6 5Als bshllpe= 2 do. n wordt rsho.pe 1 1 1 1 1 2 1

De pllr~~eter stepCNJ wordt nu ~ls volgt berekend:

TP.RNSPOSE PAR:SEGU-.\ STE?[l]:=l)

FOR 1:=1 TC a DO stepC!+lJ:=stepCIl*rshllp..,CI]jEND.

- 7~-

H~t PFC-~190ritMe voor transpose geeft net ~ls bij~tleen d~ta van AIC-B door naQr de AOC.

PFC TRANSPOSE:BEGIH Ure~d(B,AIC-B)·

"trQnsfer( R, B)HWHILE NOT EOP-B DOBEGIN dredd(B,AIC-S)jwrite(AOC,R)dj

"tl'a.nsfer< R, B)U i

EHDjuwr ite(AOC, R)·;

WHILE HOT EOP-R DO nothing:• interrupt";

END.

Tra.nspose iS een non d~t~-driven function.

8.5.6 COApressl Expa.nd.

r~verse

Co~press en expand Zijn d~tQ-driven functions. In de co~press­

operatie wordt AIC-B v~n tijd tot tijd opnieu~ geiniti~tiseerd

OM~~t er blokken overgeslagen kunnen worden. In de exp~nd­

opera.tie ~oeten er btokken ~et 0 of spatie tu~s~ngevoe9d

worden.

De COP heeft de structuur va.n het resultaat bep~a.td en de AOekan voor RMO geprograM~eerd worden. AIC-A wordt voor GRMOgeprograMMeerd. De paraMeter "rep· wordt nu:

AIC-A COMPRESS PAR:IF K=l THEH rep:=1

ELSE rep; =bshQ.p~[ 1]* bshape[ K-l];

AIC-S wordt voor RMO geprograMM~erd, M~~r d~ initialisatie vanAIC-B gebeurt alleer. vanuit het PFe-a.tgoritRP..

- 80-

Het PFC-co~p~~ss ~190rit~~ lUidt:

PFC COMPRESS:BEGIN block:=Q; b~se:=bb~se; 1~n9th:=O;

WHILE HOT EOP-A DOBEGIN continue:=TRUE;

WHILE continue AHD HOT EOP-A DOBEGIN ·re~d(A,AIC-A)·;

aco~p~~e(fl~9,A,0)U;

·WHILE HOT EOP-APU DO nothing;IF fl~g iHEH block:=block+l;

ELSE continu~:=FALSE;

END;b~se:=b~se+len9th+block*blocksize;

block:=l;continue:=~RUE;

WHILE continue AHD HOT EOP-A DOBEGIN ·re~d(A,AIC-A)·;

"coAp~re( fl~gl A,l)";·WHILE HOT EOP-APU DO nothing;IF fl~9 THEH block:=block+l;

ELSE continue:=FALSE;EHD;length:=block*blocksize;block:=t;CALL IHIT-COMPRESS;IF HOT EOP-BTHEH BEGIH "re~d(B/AIC-B)";

fttr~nsf~~( R, B)";WHILE HOT EOP-B DOBEGIH K rea d(B,AIC-8),write(AOC,R)";

·t~ansf~r(R,8;''';

END;"write<AOC,R)";

END;END;WHILE HOT EOP-R DO nothing;.. i nterrupt ft;

END.

r~jIT-COr1PRESSl

BEG I H I F .b b ~ se +b n '.J I"l be r > b ~ se +1 eng thTHEN BEGIN ·~rite(AIC-B,base)";

HIJ rit e ( AIC - Bil en 9 th ) .. ;·write(AIC-B,RMO)"

END;END.

- 81-

Het PFC-~lgo~it~e geb~uikt de p~r~Aete~

~ls volgt berekend:blocksize. Deze wo~dt

PFC COMPRESS PAR:IF K=b~ank THEN blocksize:=l

ELSE bloeks ize: =bshllpeC K+l]* .. '" *bsh~pe( bra.nk]

OpPlerking:

Het QIgo~itl'le zoals dolt hier gep~esenteerd iS werkt niet zoefficient voor een co~pressie over een vlln de {a.oltste diMensi9so~dolt 8l eng th" dlln rel~tief klein iS en er dus ~Q.~k eenherinitia.lis~tie Vlln AIC-B plQ.a.ts Ploet vinden. Bij eencOApressie over de IQ.oltste dil'lensie Plet veel 1-0-1 wisselingenblijft er weinig over voln de opzet 01'1 de dQ.t~ zo snel Mogelijkuit het geheugen te hIllen. Het enige Illterna.tief is echter OMope~a.nd B volle~ig in RHO te Illten p~sseren en ~lleen dieele~enten nCdr de AOC door te geven die door een 1 in deovereenkOMstige koloApositie in oper~nd A gekenMerkt worden.Deze Q.llnpa.k klln Uitgebreid worden voor een COMpressie OV9r eenwi llekeurige diMensie, I'llla.r dit iS weer niet efficient a.1s ereen cOMpressie over een voln de eerste di~ensies v~n grotered~t~-objecten uitgevoerd Ploet worden. In deze situa.tie za.! erveel d~t~ gelezen worden die niet in het resultQ.~t za.lvoorkoPlen.

Tenslotte bestQ.(lt er nog de Mogelijkheid OM beidete i~pleMenteren.

rea.lisilties

- 82-

Expa.nd (R.--À \[KJ B).

In de expa.nd-oper~tie worden de Aoe en Ale-B voor RMO, en Ale-Awordt voor GRMO gepragr~ft~eerd. Het PFC-~l90rit.~e luidt:

PFC-EXPAND:BEGIN IF btype=cha.ra.cter THEH "loa.d(D,bla.nk)"

ELSE Alo~d<D,O)"i

ijHILE HOT EOP-A DOBEGIN ·re~d(A,AIC-A)";

"co l'lpa.re( t' la.9' A 11 )";·WHILE NOT EOP-APU DO nothingiIF t'la.gTHEH BEGIN "rea.d(B,AIC-B)"

"tr~nst'er(R. B)";count:=!;WHILE count < blocKsize DOBEGIN nrea.d<B,AIC-B)iwrite(AOC,R)";

"tra.nsfer(R,B)"icount:=count+1i

EH D ;"write(AOe,R)"i

ENDiELSE BEGIN count:=Oi

WHILE count { blocksize DOBEGIN "write(AOe,D)";

count:=count+l;EHD;

END;END;WHILE HOT EOP-R 00 nothin9in interrupt" i

EHD.

~e pQ.ra.~eter bloc~size is dezelfde ~ls in de cOMpress-opera.tie.

B,6 Mixed priAitive t'unctio~s-other.

8.6.1 Roll (R+-? B).

De roll-operatie ka.n op dezelfde Ma.nier dls Mona.dic scala.rpriMitj~e functions behandeld worden. (Zie 8.2.1)

- 83-

B.6.2 B~se v~tue, Represent.

Oe b~se v~luê ope~~tie iS n~uw ve~w~nt n~n de inne~ productope~~tiê. Het ACC-nlgorit~e wo~dt d~n ook wee~ een RMO­~190~it~ê en de AlC-A/B ~190~it~en worden hetzelfde ~ls dein"e~ product ~190~it~tn voor A respektievelijk B (zie 8.3.4).

PFC BASE VALUE:BEGIH WHILE HOT (EOP-A AHO EOP-B) DO

BECIN are~d(B.AIC-B)";

·t~~nsfer(R,B)·;

.lo~d(D.l )a;

DO CASE REAOCOHTROL0: are~d(A,AIC-A)·:1 : • r e a.d ( A , AI C- A ) I r e ~ d ( B I AIC - B ) a ;

2: "~e~d(A, IHC-A)";3: .,. e a.à ( A I AIC - A ) , re Q. d ( B I AIC - B ) • :·"ul<D.A.D)";• ... ut(E.D.B) .. ;a~dd<R/E/R)";

count :=liWHILE count LEG rep-2 DOBEGIN DO CASE READCOHTROL

O • •• I

l:·~eQ.d(B/AIe-B)a;

2:·~eQ.d(A,AIC-A)·;

3 : n re Q. d( A, AIC - A) , ~ e Q. d ( B, AI C- B ). ;a 1'\ U 1(0, A, 0)";a f"lU t (E, 0 I B) u i

·~dd(R,E,R)";

count:=count+l;EH DiDO CASE REAOCOHTROLO:·write(AOC,R)";1 : Cl writ e( Aoe , R) " ;2:Cl"eQ.d(A,AIC-A),w~ite(AOC,R)·;

:3: u ~ e ~d (A. AIC - A) I wr i te ( A0 C, R) • ;EHO;WHILE NOT EOP-R DO nothing:• interrupt·;

EHD.

De p~rQ~eter u rep • iS weer het ~Q.Xil'\u~ va.n ~sha.peCQ.ra.nk] enbsha.peCll. READCOHTROL heeft oak dezelfde betekenis a.Is in deinne~ product a.lgo~itf"len.

- 84-

Repl"esent (R+-AT 8).

Het result~~t ~~n een represent oper~tie ~oet in een reduction­order in de worksp~ce g&schre~en worden. De AOe wordt d~n

geprogr~~~eerd voor reduction, w~~rbij de di~en~ie Y~~rover ditAoet gebeuren gegeven wordt door: K=rr~nk-br~nk (een sc~tBr

heeft r~nk 0). AIC-8 wordt geprograAMeerd voor GRMO ~et dep 11 r 111"1 eter ,. e p=11 S h Q. pet 1 J'" '" a. s h f1 P e ( ~ t' ank - 1 J. A IC - A r.J 0 r cl tgeprograMMeerd voor inner product, wlla.rbij de pa.rllAeter rep2 nugelijk ~ordt Q.Q.n bnUAber uit de AIC-B initia.tisBtie.

Het PFC-lltgoritAe luidt:

PFC REPRESEHT:BEGIN WHILE HOT(EOP-A AHD EOP-B) DO

BEGIH Dre~d(A,AIC-A),relld(B,AIC-B)K~

°residue<R,A,B)O;°di"ide<DJÎ~,8)Oj

°t"loor<D,O)"jcount:=l;WHILE count LEQ rep-l DOBEGIN °rea.d(AJAIC-A),write(AOC,R)n;

Dresidue(R,A,B)Dj°divide(O,A,B)";o;loor<D,D)·;count:=count+l)

EN D;·write(AOC,R)";

END;WHILE HOT EOP-R 00 nothing;n interrupt";

END.