Ohjaustaulukko - Control table

Image
Tämä yksinkertainen ohjaustaulukko ohjaa ohjelmavirtaa yksittäisen tulomuuttujan arvon mukaan. Jokaisessa taulukon merkinnässä on mahdollinen tuloarvo, joka on testattava tasa-arvon (implisiittinen) ja asiaankuuluva alirutiini suoritettavaksi toimintosarakkeessa. Alirutiinin nimi voidaan korvata suhteellisella aliohjelmaluvulla, jos osoittimia ei tueta

Ohjaustaulukot ovat taulukoita, jotka ohjaavat ohjausvirtaa tai joilla on tärkeä osa ohjelman ohjauksessa. Ohjaustaulukon rakenteesta tai sisällöstä ei ole jäykkiä sääntöjä - sen määrittävä ominaisuus on sen kyky ohjata ohjausvirta jollakin tavalla suorittimen tai tulkin suorittaman "suorituksen" kautta . Tällaisten taulukoiden suunnittelua kutsutaan joskus taulukko-ohjattavaksi suunnitteluksi (vaikka tämä viittaa tyypillisesti koodin luomiseen automaattisesti ulkoisista taulukoista suorien ajo-taulukoiden sijaan). Joissakin tapauksissa ohjaustaulukot voivat olla erityisiä toteutuksia äärelliseen tilaan-koneeseen perustuvaan automaattipohjaiseen ohjelmointiin . Jos ohjaustaulukossa on useita hierarkkisia tasoja, ne voivat käyttäytyä tavalla, joka vastaa UML-tilakoneita

Ohjaustaulukot usein vastaa ehdollista ilmaisuja tai toiminnon viittaukset upotettu niitä yleensä ennakoivat niiden suhteellinen sarake asemaansa yhdistyksen luetteloon . Ohjaustaulukot vähentävät samanlaisten rakenteiden tai ohjelmalausekkeiden ohjelmoinnin tarvetta uudestaan ​​ja uudestaan. Useimpien taulukoiden kaksiulotteisuus tekee niistä helpommin tarkasteltavissa ja päivitettävissä kuin ohjelmakoodin yksiulotteisuus. Joissakin tapauksissa ei-ohjelmoijat voidaan osoittaa ylläpitämään ohjaustaulukoita.

Tyypillinen käyttö

Edistyneempi käyttö

samanlainen kuin tavukoodi - mutta yleensä toiminnoilla, jotka itse taulukon rakenne viittaa

Taulukon rakenne

Taulukoilla voi olla useita ulottuvuuksia, kiinteät tai vaihtelevat pituudet, ja ne ovat yleensä siirrettävissä tietokonealustojen välillä , mikä vaatii vain muutoksen tulkkiin, ei itse algoritmiin - jonka logiikka sisältyy olennaisesti taulukon rakenteeseen ja sisältöön. Taulukon rakenne voi olla samanlainen kuin monikarttainen assosiatiivinen taulukko , jossa data-arvo (tai data-arvojen yhdistelmä) voidaan yhdistää yhteen tai useampaan suoritettavaan toimintoon.

Yksiulotteiset taulukot

Ehkä yksinkertaisimmassa toteutuksessaan ohjaustaulukko voi joskus olla yksiulotteinen taulukko raakatietoarvon suoraan kääntämiseksi vastaavaksi aliohjelman siirtymäksi , indeksiksi tai osoittimeksi käyttämällä raakatietoarvoa joko suoraan taulukon indeksinä tai suorittamalla joitakin aritmeettisia tietoja tiedoista etukäteen. Tämä voidaan saavuttaa vakio ajan (ilman lineaarinen haku tai binäärinen haku käyttäen tyypillistä hakutaulukkoon koskevasta assosiatiivisia array ). Useimmissa arkkitehtuureissa tämä voidaan toteuttaa kahdella tai kolmella koneohjeella - ilman vertailuja tai silmukoita. Tekniikkaa kutsutaan " triviaaliksi hash-funktioksi " tai, kun sitä käytetään erityisesti haarapöytiin, " double dispatch ". Jotta tämä olisi mahdollista, datan kaikkien mahdollisten arvojen alueen on oltava pieni (esim. ASCII- tai EBCDIC-merkkiarvo, jolla on heksadesimaaliluku '00' - 'FF'. Jos todellinen alue taataan pienemmäksi matriisi voidaan katkaista alle 256 tavuun).

Taulukko, jolla käännetään ASCII-raaka-arvot (A, D, M, S) uuteen alirutiini-indeksiin (1,4,3,2) vakiona, käyttäen yksiulotteista taulukkoa

(alueen aukot esitetään tässä esimerkissä "..", mikä tarkoittaa "kaikkia heksadesimaaliarvoja seuraavaan riviin asti". Kaksi ensimmäistä saraketta eivät ole osa taulukkoa)

ASCII Hex Taulukko
tyhjä 00 00
.. .. 00
@ 40 00
A 41 01
.. .. 00
D. 44 04
.. .. 00
M 4D 03
.. .. 00
S 53 02

In automaatti-ohjelmointi ja pseudoconversational tapahtuman käsittely, jos määrä eri ohjelma toteaa on pieni, "tiheä sekvenssi" säätömuuttuja voidaan käyttää tehokkaasti sanella koko virtaus pääohjelmasilmukasta.

Kahden tavun raakatiedon arvo vaatisi vähintään 65 536 tavun taulukon koon - kaikkien syöttömahdollisuuksien käsittelemiseksi - sallien samalla vain 256 erilaista lähtöarvoa. Tämä suora käännöstekniikka tarjoaa kuitenkin erittäin nopean validoinnin ja muuntamisen (suhteelliseksi) aliohjelmaosoittimeksi, jos heuristiikka yhdessä riittävän nopean muistin kanssa sallii sen käytön.

Haarapöydät

Pääartikkeli: Haarapöytä

Haara taulukko on yksiulotteinen 'matriisi' vierekkäisten koneen koodi haara / hyppy ohjeet, jotta saadaan aikaan moniraitainen haara on ohjelma merkintä, kun haarautunut jota välittömästi edeltävän, ja indeksoitu haara. Optimoiva kääntäjä tuottaa sen joskus suorittamaan kytkinlausekkeen - edellyttäen, että syöttöalue on pieni ja tiheä, ja siinä on vähän aukkoja (kuten edellisessä taulukkoesimerkissä on luotu) [2] .

Vaikka Ifhaaran ohjeet ovatkin melko pienikokoisia - verrattuna moniin vastaaviin lausekkeisiin -, niillä on silti jonkin verran redundanssia, koska haaran opkoodi ja ehtokoodimaski toistetaan haarasiirtymien rinnalla. Ohjaustaulukot, jotka sisältävät vain ohjelmasiirtymien siirtymät, voidaan rakentaa tämän redundanssin voittamiseksi (ainakin kokoonpanokielillä) ja vaativat kuitenkin vain vähäistä suoritusaikaa yleiskustannuksiin verrattuna tavanomaiseen haarataulukkoon.

Moniulotteiset taulukot

Useammin, valvonta taulukko voidaan ajatella Totuustaulukko tai suoritettavana ( "binary") täytäntöönpano painetun päätöstaulu (tai puu päätöstaulukoiden useilla tasoilla). Ne sisältävät (usein implisiittisiä) ehdotuksia yhdessä yhden tai useamman liittyvän 'toiminnan' kanssa. Nämä toiminnot suoritetaan yleensä yleisillä tai räätälöityillä aliohjelmilla , joita kutsutaan " tulkki " -ohjelmaksi. Tulkki toimii tässä tapauksessa tehokkaasti virtuaalikoneena , joka 'suorittaa' ohjaustaulukon merkinnät ja tarjoaa siten korkeamman abstraktiotason kuin tulkin taustalla oleva koodi.

Ohjaustaulukko voidaan rakentaa samalla tavalla kuin kielestä riippuvainen kytkinlauseke, mutta lisätty mahdollisuus testata tuloarvojen yhdistelmiä (käyttäen loogista tyyliä JA / TAI- ehtoja) ja mahdollisesti kutsua useita aliohjelmia (vain yhden arvojoukon sijasta) ja 'haara' ohjelmatunnisteet). (Kytkinlausekekonstruktio ei välttämättä ole saatavana, tai siinä on hämmentävän erilaiset toteutukset korkean tason kielillä ( HLL ). Ohjaustaulukonseptilla ei ole sisäisiä kieliriippuvuuksia, mutta se voidaan kuitenkin toteuttaa eri tavalla käytettävissä olevien kielien mukaan valitun ohjelmointikielen tietojen määrittelyominaisuudet.)

Taulukon sisältö

Ohjaustaulukko ilmentää olennaisesti tavanomaisen ohjelman " olemusta ", josta on poistettu ohjelmointikielen syntaksin ja alustasta riippuvat komponentit (esim. JOS / SITTEN TEHDÄ .. tiivistetty 'sen muuttujiin (esim. input1), arvoihin (esim.' A ',' S ',' M 'ja' D ') ja alirutiinitunnuksiin (esim.' Lisää ',' vähennä, .. 'tai # 1, # 2, ..). Taulukon rakenne itsessään tarkoittaa tyypillisesti (oletus) loogisia toimintoja - kuten "tasa-arvon testaus", aliohjelman suorittaminen ja "seuraava operaatio" tai oletussekvenssin noudattaminen (sen sijaan, että nämä ilmoitettaisiin nimenomaisesti ohjelmalausekkeissa - tarpeen mukaan) muissa ohjelmointiparadigmoissa ).

Moniulotteinen ohjaustaulukko sisältää yleensä vähintään arvo / toimintapareja ja voi lisäksi sisältää operaattoreita ja tyyppitietoja , kuten syöttö- tai lähtödatan sijainnin, koon ja muodon, onko tietojen muunnos (tai muu ajonaika) käsittelyvivahteita) vaaditaan ennen käsittelyä tai sen jälkeen (ellei sitä jo ole implisiittisesti itse toiminnossa). Taulukko voi sisältää tai ei välttämättä sisältää hakemistoja tai suhteellisia tai absoluuttisia viitteitä yleisiin tai räätälöityihin primitiiveihin tai aliohjelmiin , jotka suoritetaan riippuen muista "rivin" arvoista.

Seuraavassa esitetty taulukko koskee vain tuloa1, koska taulukossa ei ole määritelty mitään erityistä syötettä.

olosuhteet ja toimet, joihin rakenne viittaa

(implisiittinen) JOS = (implisiittinen) suorittaa
arvo toiminta
arvo toiminta

(Tällä vierekkäisellä arvon ja toiminnan pariliitoksella on yhtäläisyyksiä tapahtumapohjaisen ohjelmoinnin rakenteisiin , nimittäin 'tapahtuman havaitseminen' ja 'tapahtumankäsittely', mutta ilman itse tapahtuman asynkronista luonnetta.)

Ohjaustaulukkoon koodattavien arvojen valikoima riippuu suurelta osin käytetystä tietokoneen kielestä . Kokoonpanokieli tarjoaa laajimman laajuuden tietotyypeille, mukaan lukien (toiminnoille) mahdollisuus suoraan suoritettavaan konekoodiin . Tyypillisesti ohjaustaulukko sisältää arvot jokaiselle mahdolliselle vastaavalle tuloluokalle yhdessä vastaavan osoittimen toiminnan aliohjelmaan. Jotkut kielet väittävät, etteivät ne tue osoittimia (suoraan), mutta voivat silti tukea indeksiä, jota voidaan käyttää edustamaan 'suhteellista aliohjelmalukua' ehdollisen suorituksen suorittamiseksi, jota ohjataan taulukon merkinnässä olevalla arvolla (esim. Käytettäväksi optimoidussa SWITCHissa) lause - suunniteltu ilman aukkoja (ts. monitiehaara ).

Jokaisen sarakkeen yläpuolelle sijoitetut kommentit (tai jopa upotetut tekstidokumentit) voivat tehdä päätöksestäulukon "ihmisen luettavissa" myös sen jälkeen, kun "tiivistyminen" (koodaus) on olennaista (ja silti pitkälti alkuperäisen ohjelmaspesifikaation mukaisesti - varsinkin jos painettu päätöstaulu, luetellaan kukin yksittäinen toiminta, on luotu ennen koodausta alkaa). Taulukkomerkinnät voivat myös sisältää laskureita ajoaikatilastojen keräämiseksi 'lennon aikana' tai myöhempää optimointia varten

Pöydän sijainti

Ohjaustaulukot voivat sijaita staattisessa tallennustilassa, apuvälineessä , kuten tasaisessa tiedostossa tai tietokannassa, tai ne voidaan vaihtoehtoisesti rakentaa osittain tai kokonaan dynaamisesti ohjelman alustushetkellä parametreista (jotka itse voivat olla taulukossa). Parhaan tehokkuuden saavuttamiseksi taulukon tulisi olla muistissa, kun tulkki alkaa käyttää sitä.

Tulkki ja aliohjelmat

Tulkki voidaan kirjoittaa millä tahansa sopivalla ohjelmointikielellä, mukaan lukien korkean tason kieli . Sopivasti suunniteltu yleinen tulkki sekä hyvin valittu joukko yleisiä aliohjelmia (kykenevät käsittelemään yleisimmin esiintyviä primitiivejä ) edellyttäisivät tavanomaista lisäkoodausta vain uusille mukautetuille aliohjelmille (itse ohjaustaulukon määrittelyn lisäksi). Tulkki voi valinnaisesti soveltaa vain joihinkin tarkoin määriteltyihin osiin täydellistä sovellusohjelmaa (kuten pääohjaussilmukka ), eikä muihin, vähemmän ehdollisiin osioihin (kuten ohjelman alustus, lopetus ja niin edelleen).

Tulkin ei tarvitse olla kohtuuttoman monimutkainen, eikä sitä tule tuottaa ohjelmoijalta, jolla on kääntäjän kirjoittajan edistyneet tiedot, ja se voidaan kirjoittaa aivan kuten mikä tahansa muu sovellusohjelma - paitsi että se on yleensä suunniteltu tehokkuutta silmällä pitäen. Sen ensisijainen tehtävä on "suorittaa" taulukon merkinnät joukko "ohjeita". Ohjaustaulukon merkintöjen jäsentämiselle ei tarvitse olla vaatimusta, ja ne on sen vuoksi suunniteltava mahdollisuuksien mukaan 'suoritusvalmiiksi', edellyttäen vain muuttujien "kytkemistä" sopivista sarakkeista jo koottuun yleiseen koodiin. tulkki. Ohjelman ohjeet ovat, teoriassa, äärettömän laajennettavissa ja muodostavat (mahdollisesti mielivaltaista) arvojen taulukon jotka ovat mielekkäitä vain tulkki. Valvonta virtaus tulkin on tavallisesti peräkkäinen käsittely Kunkin taulukon rivin vaan sitä voidaan muunnella erityisten toimia taulukon merkinnät.

Nämä mielivaltaiset arvot voidaan siten suunnitella tehokkuutta silmällä pitäen - valitsemalla arvot, joita voidaan käyttää suorina hakemistoina data- tai toiminto-osoittimille . Erityisestä alustat / kieltä , he voivat olla erityisesti suunniteltu minimoimaan käskytiellä pituudet käyttämällä haara taulukon arvoja tai jopa joissakin tapauksissa, kuten tutkintaryhmän kerääjiä, koostuvat suoraan suoritettavan konekoodia " katkelmia " (tai osoittimet niihin).

Alirutiinit voidaan koodata joko samalla kielellä kuin tulkki itse tai millä tahansa muulla tuetulla ohjelmakielellä (edellyttäen, että on olemassa sopivat kielien väliset puheluyhteysmekanismit). Tulkin ja / tai aliohjelmien kielen valinta riippuu yleensä siitä, kuinka siirrettävän sen on oltava eri alustoilla . Tulkista voi olla useita versioita ohjaustaulukon siirrettävyyden parantamiseksi. Alisteinen ohjaustaulukon osoitin voi valinnaisesti korvata aliohjelman osoittimen "action" -sarakkeissa, jos tulkki tukee tätä rakennetta, mikä edustaa ehdollista "pudotusta" alemmalle loogiselle tasolle, matkimalla tavanomaista jäsennettyä ohjelmarakennetta .

Suorituskykyä koskevat näkökohdat

Ensi silmäyksellä ohjaustaulukoiden käyttö näyttäisi lisäävän melko paljon ohjelman yleiskustannuksia , mikä vaatii tulkkiprosessia, ennen kuin "alkuperäisen" ohjelmointikielen käskyt suoritetaan. Näin ei kuitenkaan aina ole. Erottamalla (tai "kapseloimalla") suoritettava koodaus logiikasta, kuten taulukossa on esitetty, se voidaan kohdistaa helpommin suorittamaan tehtävänsä tehokkaimmin. Tämä voidaan kokea ilmeisimmin taulukkolaskentaohjelmassa - missä taustalla oleva taulukkolaskentaohjelmisto muuntaa läpinäkyvästi monimutkaiset loogiset 'kaavat' tehokkaimmalla mahdollisella tavalla, jotta tulokset voidaan näyttää.

Seuraavat esimerkit on valittu osittain havainnollistamaan potentiaalisia suorituskyvyn parannuksia, jotka voivat paitsi kompensoida merkittävästi lisätaitotasoa, mutta myös parantaa vähemmän tehokasta, vähemmän ylläpidettävää ja pidempää koodia. Vaikka esitetyt esimerkit koskevat 'matalan tason' kokoonpanokieliä ja C-kieltä , voidaan molemmissa tapauksissa nähdä, että ohjaustaulukkoa koskevan lähestymistavan toteuttamiseksi tarvitaan hyvin vähän koodiriviä ja että ne voivat kuitenkin saavuttaa erittäin merkittävän vakioajan suorituskyvyn parannuksia, vähentää toistuvia lähde koodaus ja selventävät, verrattuna monisanainen tavanomaisia ohjelmia kielen ominaisuuksia. Katso myös lainaukset by Donald Knuth , jotka koskevat taulukoita ja tehokkuutta multiway haarautuvan tässä artikkelissa.

Esimerkkejä ohjaustaulukoista

Seuraavat esimerkit ovat mielivaltaisia (ja perustuvat vain yhteen syötteeseen yksinkertaisuuden vuoksi), mutta tarkoituksena on kuitenkin vain osoittaa, kuinka ohjausvirta voidaan toteuttaa käyttämällä taulukoita säännöllisten ohjelmalausekkeiden sijaan. On oltava selvää, että tätä tekniikkaa voidaan helposti laajentaa käsittelemään useita syötteitä joko lisäämällä sarakkeiden määrää tai käyttämällä useita taulukon merkintöjä (valinnaisen ja / tai operaattorin kanssa). Vastaavasti käyttämällä (hierarkkisia) linkitettyjä ohjaustaulukoita voidaan toteuttaa jäsennelty ohjelmointi (vaihtoehtoisesti sisennyksen avulla korostamaan alemman tason ohjaustaulukoita).

"CT1" on esimerkki ohjaustaulusta, joka on yksinkertainen hakutaulukko . Ensimmäinen sarake edustaa tulon arvo testataan (mukaan hiljaista 'IF input1 = x') ja, jos TOSI, joka vastaa 2 sarakkeessa (jäljempänä 'tapahtuma') sisältää aliohjelma osoite suorittaa, jonka puhelu (tai hypätä ja - samanlainen kuin SWITCH- käsky). Se on itse asiassa monitievä haara, jolla on paluu (" dynaamisen lähetyksen " muoto). Viimeinen merkintä on oletustapaus, jossa vastaavuutta ei löydy.

CT1

tulo 1 osoitin
A -> Lisää
S -> Vähennä
M -> Kerro
D. -> Jaa
? -> Oletus

Jos ohjelmointikieli tukee tietorakenteissa olevia osoittimia muiden data-arvojen rinnalla, yllä olevaa taulukkoa (CT1) voidaan käyttää ohjaamaan virtaus sopiviin aliohjelmiin taulukon vastaavan arvon mukaan (ilman saraketta, joka osoittaisi toisin, tasa-arvo oletetaan tämä yksinkertainen tapaus).

Konekielellä esimerkiksi varten IBM / 360 (maksimi 16 Mt-osoitteet) tai Z / Arkkitehtuuri

Tämän ensimmäisen esimerkin koodauksen hakua ei yritetä optimoida, ja se käyttää sen sijaan yksinkertaista lineaarista hakutekniikkaa - pelkästään havainnollistamaan konseptia ja osoittamaan vähemmän lähdeviivoja. Kaikkien 256 eri syöttöarvon käsittelemiseksi tarvitaan noin 265 lähdekoodiriviä (lähinnä yhden rivin taulukon merkinnät), kun taas useita vertailua ja haarautumista olisi yleensä tarvittu noin 512 lähdekoodiriville ( binäärikoko on myös noin puolittunut, jokainen taulukon merkintä vaatii vain 4 tavua noin 8 tavun sijasta sarjaan vertaile välitöntä / haara -ohjetta (Suuremmille syötemuuttujille säästö on vielä suurempi). 

  * ------------------ interpreter --------------------------------------------*
           LM     R14,R0,=A(4,CT1,N)               Set R14=4, R15 --> table, and R0 =no. of entries in table (N)
  TRY      CLC    INPUT1,0(R15)         *********  Found value in table entry ?
           BE     ACTION                * loop  *  YES, Load register pointer to sub-routine from table
           AR     R15,R14               *       *  NO, Point to next entry in CT1 by adding R14 (=4)
           BCT    R0,TRY                *********  Back until count exhausted, then drop through
  .             default action                          ... none of the values in table match, do something else
           LA     R15,4(R15)                       point to default entry (beyond table end)
  ACTION   L      R15,0(R15)                       get pointer into R15,from where R15 points
           BALR   R14,R15                          Perform the sub-routine ("CALL" and return)
           B      END                              go terminate this program
  * ------------------ control table -----------------------------------------*
  *                 | this column of allowable EBCDIC or ASCII values is tested '=' against variable 'input1'
  *                 |      | this column is the 3-byte address of the appropriate subroutine
  *                 v      v
  CT1      DC     C'A',AL3(ADD)                    START of Control Table (4 byte entry length)
           DC     C'S',AL3(SUBTRACT)
           DC     C'M',AL3(MULTIPLY)
           DC     C'D',AL3(DIVIDE)
  N        EQU    (*-CT1)/4                        number of valid entries in table (total length / entry length)
           DC     C'?',AL3(DEFAULT)                default entry – used on drop through to catch all
  INPUT1   DS     C                                input variable is in this variable
  * ------------------ sub-routines ------------------------------------------*
  ADD      CSECT                                   sub-routine #1 (shown as separate CSECT here but might
  .                                                                alternatively be in-line code)
  .            instruction(s) to add
           BR     R14                              return
  SUBTRACT CSECT                                   sub-routine #2
  .            instruction(s) to subtract
           BR     R14                              return
  . etc..

parantamalla tulkin suorituskykyä yllä olevassa esimerkissä

Jos haluat tehdä valinnan yllä olevassa esimerkissä, keskimääräinen komentopolun pituus (lukuun ottamatta aliohjelmakoodia) on '4n / 2 +3', mutta se voidaan helposti vähentää, missä n = 1-64, vakioksi ajaksi polun pituudella '5: stä nolla vertailua , jos ensin käytetään 256 tavun kääntotaulukkoa luomaan suora indeksi CT1: een EBCDIC-raakatiedoista. Jos n = 6, tämä vastaisi sitten vain kolmea peräkkäistä vertailu- ja haaroitusohjetta. Kuitenkin, kun n <= 64, se tarvitsee keskimäärin noin 13 kertaa vähemmän ohjeita kuin useiden vertailujen käyttö. Jos n = 1 - 256, se käyttäisi keskimäärin noin 42 kertaa vähemmän käskyjä - koska tässä tapauksessa tarvitaan yksi lisäohje (indeksin kertominen 4: llä).

Parannettu tulkki (jopa 26 kertaa vähemmän suoritettuja ohjeita kuin keskimäärin edellisessä esimerkissä, jossa n = 1-64 ja jopa 13 kertaa vähemmän kuin mitä tarvittaisiin käyttämällä useita vertailuja).

64 erilaisen syöttöarvon käsittelemiseksi tarvitaan noin 85 riviä lähdekoodia (tai vähemmän) (lähinnä yhden rivin taulukon merkinnät), kun taas useat vertailut ja haarat vaativat noin 128 riviä ( binäärikoko on myös melkein puolittunut - huolimatta 256 tavun ylimääräinen taulukko, jota tarvitaan toisen indeksin purkamiseen). 

  * ------------------ interpreter --------------------------------------------*
           SR     R14,R14               *********  Set R14=0
  CALC     IC     R14,INPUT1            * calc  *  put EBCDIC byte into lo order bits (24–31) of R14
           IC     R14,CT1X(R14)         *       *  use EBCDIC value as index on table 'CT1X' to get new index
  FOUND    L      R15,CT1(R14)          *********  get pointer to subroutine using index (0,4, 8 etc.)
           BALR   R14,R15                          Perform the sub-routine ("CALL" and return or Default)
           B      END                              go terminate this program
  * --------------- additional translate table (EBCDIC --> pointer table INDEX)  256 bytes----*
  CT1X     DC     12AL1(00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00)   12 identical sets of 16 bytes of x'00
  *                                                                        representing X'00 – x'BF'
           DC     AL1(00,04,00,00,16,00,00,00,00,00,00,00,00,00,00,00)      ..x'C0' – X'CF'
           DC     AL1(00,00,00,00,12,00,00,00,00,00,00,00,00,00,00,00)      ..x'D0' – X'DF'
           DC     AL1(00,00,08,00,00,00,00,00,00,00,00,00,00,00,00,00)      ..x'E0' – X'EF'
           DC     AL1(00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00)      ..x'F0' – X'FF'
  * the assembler can be used to automatically calculate the index values and make the values more user friendly
  * (for e.g. '04' could be replaced with the symbolic expression 'PADD-CT1' in table CT1X above)
  * modified CT1 (added a default action when index = 00, single dimension, full 31 bit address)
  CT1      DC     A(DEFAULT)          index       =00      START of Control Table (4 byte address constants)
  PADD     DC     A(ADD)                          =04
  PSUB     DC     A(SUBTRACT)                     =08
  PMUL     DC     A(MULTIPLY)                     =12
  PDIV     DC     A(DIVIDE)                       =16
  * the rest of the code remains the same as first example

Parempi tulkki (jopa 21 kertaa vähemmän suoritettuja käskyjä (missä n> = 64) kuin ensimmäisessä esimerkissä keskimäärin ja jopa 42 kertaa vähemmän kuin mitä tarvittaisiin käyttämällä useita vertailuja).

256 eri syöttöarvon käsitteleminen, noin 280 riviä lähdekoodia tai vähemmän, vaaditaan (lähinnä yhden rivin taulukkomerkinnät), kun taas useat vertailut ja haarat vaativat noin 512 riviä (myös binäärikoko puolittuu kerran lisää). 

  * ------------------ interpreter --------------------------------------------*
           SR     R14,R14               *********  Set R14=0
  CALC     IC     R14,INPUT1            * calc  *  put EBCDIC byte into lo order bits (24–31) of R14
           IC     R14,CT1X(R14)         *       *  use EBCDIC value as index on table 'CT1X' to get new index
           SLL    R14,2                 *       *  multiply index by 4 (additional instruction)
  FOUND    L      R15,CT1(R14)          *********  get pointer to subroutine using index (0,4, 8 etc.)
           BALR   R14,R15                          Perform the sub-routine ("CALL" and return or Default)
           B      END                              go terminate this program
  * --------------- additional translate table (EBCDIC --> pointer table INDEX)  256 bytes----*
  CT1X     DC     12AL1(00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00)   12 identical sets of 16 bytes of x'00'
  *                                                                        representing X'00 – x'BF'
           DC     AL1(00,01,00,00,04,00,00,00,00,00,00,00,00,00,00,00)      ..x'C0' – X'CF'
           DC     AL1(00,00,00,00,03,00,00,00,00,00,00,00,00,00,00,00)      ..x'D0' – X'DF'
           DC     AL1(00,00,02,00,00,00,00,00,00,00,00,00,00,00,00,00)      ..x'E0' – X'EF'
           DC     AL1(00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00)      ..x'F0' – X'FF'
  * the assembler can be used to automatically calculate the index values and make the values more user friendly
  * (for e.g. '01' could be replaced with the symbolic expression 'PADD-CT1/4' in table CT1X above)
  * modified CT1 (index now based on 0,1,2,3,4  not 0,4,8,12,16 to allow all 256 variations)
  CT1      DC     A(DEFAULT)          index       =00      START of Control Table (4 byte address constants)
  PADD     DC     A(ADD)                          =01
  PSUB     DC     A(SUBTRACT)                     =02
  PMUL     DC     A(MULTIPLY)                     =03
  PDIV     DC     A(DIVIDE)                       =04
  * the rest of the code remains the same as the 2nd example

C-kieli- esimerkki Tämä esimerkki C: stä käyttää kahta taulukkoa, joista ensimmäinen (CT1) on yksinkertainen lineaarinen haun yksiulotteinen hakutaulukko - indeksin saamiseksi ottamalla sisäänsyöttö (x) ja toinen liitetty taulukko (CT1p) on taulukko osoitetiedoista, joihin voit siirtyä. 

 static const char  CT1[] = {  "A",   "S",        "M",        "D" };                          /* permitted input  values */
 static const void *CT1p[] = { &&Add, &&Subtract, &&Multiply, &&Divide, &&Default};           /* labels to goto & default*/
 for (int i = 0; i < sizeof(CT1); i++)      /* loop thru ASCII values                                                    */
   {if (x==CT1[i]) goto *CT1p[i]; }       /* found --> appropriate label                                               */
 goto *CT1p[i+1];                           /* not found --> default label                                               */

Tämä voidaan tehdä tehokkaammaksi, jos 256 tavun taulukkoa käytetään kääntämään raaka ASCII-arvo (x) suoraan tiheäksi peräkkäiseksi indeksiarvoksi käytettäväksi haaraosoitteen löytämisessä suoraan CT1p: stä (ts. " Indeksikartoitus " tavunlaajuisesti taulukko). Sitten se suorittaa vakiona kaikki x: n mahdolliset arvot (jos CT1p sisälsi funktioiden nimet tarrojen sijasta, hyppy voidaan korvata dynaamisella funktiokutsulla, joka eliminoi kytkimen kaltaisen toiminnan - mutta heikentää suorituskykyä lisäkustannuksilla toiminnallinen siivous ). 

 static const void *CT1p[] = {&&Default, &&Add, &&Subtract, &&Multiply, &&Divide};
 /* the 256 byte table, below, holds values (1,2,3,4), in corresponding ASCII positions (A,S,M,D), all others set to 0x00 */
 static const char CT1x[]={
             '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00',
             '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00',
             '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00',
             '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00',
             '\x00', '\x01', '\x00', '\x00', '\x04', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x03', '\x00', '\x00',
             '\x00', '\x00', '\x00', '\x02', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00',
             '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00',
             '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00',
             '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00',
             '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00',
             '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00',
             '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00',
             '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00',
             '\x00', '\x00', '\x00', '\x00', '\x03', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00',
             '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00',
             '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00'};
 /* the following code will execute in constant time, irrespective of the value of the input character (x)                    */
 i = CT1x(x);            /* extract the correct subroutine index from table CT1x using its ASCII value as an index initially  */
 goto *CT1p[i];          /* goto (Switch to) the label corresponding to the index (0=default, 1=Add, 2=Subtract,.) - see CT1p */

Seuraava esimerkki kuvaa, kuinka samanlainen vaikutus voidaan saavuttaa kieliä, jotka eivät ole tue osoitin määritelmien tietorakenteita, mutta eivät tuki indeksoitu haarautumisen aliohjelmaan -, joka sisältyy ( 0-pohjainen ) joukko aliohjelma osoittimia. Taulukkoa (CT2) käytetään indeksin purkamiseen (toisesta sarakkeesta) osoitinryhmään (CT2P). Jos osoitinmatriiseja ei tueta, SWITCH-käskyä tai vastaavaa voidaan käyttää muuttamaan ohjausvirta ohjelmakoodien sarjaksi (esim. Tapaus0, tapaus1, tapaus2, tapaus3, tapaus4), jotka sitten joko käsittelevät syötteen suoraan tai muuten soita (paluu) sopivaan alirutiiniin (oletus, Lisää, vähennä, kerro tai jaa, ..) käsittelemään sitä.

CT2

tulo 1 subr #
A 1
S 2
M 3
D. 4
? 0

Kuten yllä olevissa esimerkeissä, on mahdollista muuntaa erittäin tehokkaasti potentiaaliset ASCII- tuloarvot (A, S, M, D tai tuntematon) osoitinryhmäindeksiin ilman, että tosiasiallisesti käytetään taulukkohakua, mutta se on tässä esitetty taulukkona yhdenmukaisuuden kanssa ensimmäinen esimerkki.

CT2P osoitin array
osoitin array
-> oletus
-> Lisää
-> Vähennä
-> Kerro
-> Jaa
->? muut

Moniulotteisia ohjaustaulukoita voidaan rakentaa (ts. Räätälöidä), jotka voivat olla "monimutkaisempia" kuin yllä olevat esimerkit, jotka saattavat testata useita ehtoja useilla tuloilla tai suorittaa useamman kuin yhden "toiminnon" joidenkin yhteensopivuuskriteerien perusteella. 'Toiminto' voi sisältää osoittimen toiseen alisteiseen ohjaustaulukkoon. Alla olevassa yksinkertaisessa esimerkissä implisiittinen TAI-ehto on sisällytetty ylimääräiseksi sarakkeeksi (pienten kirjainten käsittelemiseksi, mutta tässä tapauksessa tämä olisi voitu hoitaa myös yksinkertaisesti siten, että jokaiselle pienelle kirjaimelle on lisämerkintä, joka määrittää sama aliohjelman tunniste kuin isoilla kirjaimilla). Mukana on myös ylimääräinen sarake, joka laskee kunkin syötteen todelliset ajoaikaiset tapahtumat niiden tapahtuessa.

CT3

tulo 1 vuorotellen subr # Kreivi
A a 1 0
S s 2 0
M m 3 0
D. d 4 0
? ? 0 0

Ohjaustaulukon merkinnät ovat tällöin paljon samanlaisia ​​kuin ehdolliset lauseet menettelykielillä, mutta ratkaisevasti ilman, että todellisia (kielestä riippuvia) ehdollisia lauseita (eli käskyjä) on läsnä (yleinen koodi on fyysisesti tulkissa, joka käsittelee taulukon merkintöjä, ei itse taulukossa - joka yksinkertaisesti ilmentää ohjelmalogiikkaa sen rakenteen ja arvojen kautta).

Tällaisissa taulukoissa, joissa samanlaisten taulukkomerkintöjen sarja määrittelee koko logiikan, taulukon merkinnän numero tai osoitin voi tosiasiallisesti korvata ohjelmalaskurin sijainnin tavanomaisemmissa ohjelmissa ja se voidaan nollata myös toiminnossa, joka on määritelty myös kohdassa taulukon merkintä. Alla oleva esimerkki (CT4) osoittaa, kuinka edellisen taulukon laajentaminen 'seuraavan' merkinnän sisällyttämiseksi (ja / tai 'alter flow' ( hypätä ) aliohjelman sisällyttäminen) voi luoda silmukan (Tämä esimerkki ei todellakaan ole tehokkain tapa rakenna tällainen ohjaustaulukko, mutta osoittamalla asteittaisen 'evoluution' yllä olevista ensimmäisistä esimerkeistä, osoittaa kuinka lisäsarakkeita voidaan käyttää käyttäytymisen muuttamiseen.) Viides sarake osoittaa, että useampi kuin yksi toiminto voidaan aloittaa yhdellä taulukon merkinnällä - tässä tapauksessa suoritettavan toiminnon jälkeen normaalin käsittelyn kukin merkintä ( '-' arvot keskimääräinen 'ei olosuhteet' tai 'ei toimintaa').

Rakenteinen ohjelmointi tai "Goto-less" -koodi (joka sisältää vastaavanlaisen DO WHILE- tai " for loop " -rakenteita) voidaan myös sijoittaa sopivasti suunniteltujen ja "sisennyttyjen" ohjaustaulukorakenteiden kanssa.

CT4 (täydellinen 'ohjelma' tulon1 ja prosessin lukemiseen, toistetaan, kunnes 'E' havaitaan)

tulo 1 vuorotellen subr # Kreivi hypätä
- - 5 0 -
E e 7 0 -
A a 1 0 -
S s 2 0 -
M m 3 0 -
D. d 4 0 -
? ? 0 0 -
- - 6 0 1
CT4P osoitin array
osoitin array
-> Oletus
-> Lisää
-> Vähennä
-> Kerro
-> Jaa
-> Lue tulo1
-> Vaihda virtaus
-> Loppu

Taulukko-ohjattava luokitus

Televiestinnän luokittelun erikoisalalla (joka koskee tietyn puhelun hinnan määrittämistä) taulukko-ohjattavat luokitustekniikat kuvaavat ohjaustaulukoiden käyttöä sovelluksissa, joissa säännöt voivat muuttua usein markkinavoimien vuoksi. Muut kuin ohjelmoijat voivat muuttaa maksuja määrittäviä taulukoita lyhyellä varoitusajalla.

Jos algoritmeja ei ole valmiiksi rakennettu tulkkiin (ja vaativat siksi taulukossa olevan lausekkeen ylimääräistä ajonaikaista tulkintaa), se tunnetaan nimellä "Sääntöpohjainen luokitus" eikä taulukkopohjainen luokitus (ja kuluttaa siten huomattavasti enemmän yleiskustannuksia) ).

Laskentataulukot

Laskentataulukon tiedot voidaan ajatella kaksiulotteinen ohjaus taulukko, jossa ei tyhjät solut edustavat tiedot alla olevaan taulukkolaskentaohjelmaan (tulkki). Kaavan sisältävät solut on yleensä etuliitetty yhtäläisyysmerkillä, ja ne yksinkertaisesti nimeävät erityistyyppisen tietojen syötteen, joka sanelee muiden viitattujen solujen prosessoinnin muuttamalla tulkin sisäistä ohjausvirtaa. Kaavojen ulkoistaminen taustalla olevasta tulkista tunnistaa selvästi molemmat laskentataulukot ja yllä mainitun "sääntöpohjaisen luokituksen" esimerkin helposti tunnistettavissa olevina tapauksina, kun muut kuin ohjelmoijat käyttävät ohjaustaulukoita.

Ohjelmointiparadigma

Jos ohjaustaulukotekniikan voidaan sanoa kuuluvan johonkin tiettyyn ohjelmointiparadigmaan , lähin analogia saattaa olla automaattipohjainen ohjelmointi tai "heijastava" ( metaprogrammin muoto), koska taulukon merkintöjen voidaan sanoa 'muuttavan' tulkki). Tulkki itse ja alirutiinit voidaan kuitenkin ohjelmoida käyttämällä mitä tahansa käytettävissä olevista paradigmista tai jopa seosta. Taulukko itsessään voi olennaisesti olla kokoelma " raakatiedot " -arvoja, joita ei edes tarvitse koota ja jotka voidaan lukea ulkoisesta lähteestä (lukuun ottamatta erityisiä, alustasta riippuvia toteutuksia, jotka käyttävät suoraan muistiosoittimia paremman tehokkuuden saavuttamiseksi).

Analogia tavukoodiin / virtuaalikoneen käskyjoukkoon

Moniulotteisella ohjaustaulukolla on joitain käsitteellisiä yhtäläisyyksiä virtuaalikoneessa toimivien tavujen koodeihin , koska todellisen suorituksen suorittamiseen tarvitaan yleensä alustasta riippuvainen "tulkki" -ohjelma (joka on suurelta osin ehdollisesti määritelty taulukoiden sisällön mukaan). On myös joitain käsitteellisiä yhtäläisyyksiä viimeaikaisen Common Intermediate Language (CIL) -kielen kanssa tavoitteena luoda yhteinen välitasoinen 'ohjeisto', joka on riippumaton alustasta (mutta toisin kuin CIL, ei mitään väitteitä käytettäväksi yhteisenä resurssina muille kielille) . P-koodia voidaan myös pitää samanlaisena, mutta aikaisempana toteutuksena, jonka alkuperä on peräisin jo vuonna 1966.

Ohjehaku

Kun moniulotteista ohjaustaulukkoa käytetään ohjelmavirran määrittämiseen, normaalia "laitteisto" ohjelmalaskuritoimintoa simuloidaan tehokkaasti joko osoittimella ensimmäiseen (tai seuraavaan) taulukon merkintään tai muuten siihen hakemistoon . Komennon "noutaminen" käsittää kyseisen taulukon merkinnän tietojen dekoodaamisen - välttämättä kopioimalla ensin kaikkia tietoja tai osan niistä. Ohjelmointikielillä, jotka pystyvät käyttämään osoittimia, on kaksi etua, että vähemmän yleiskustannuksia aiheutuu sekä sisällön saannista että myös laskurin edistämisestä osoittamaan seuraavaan taulukon merkintään suorituksen jälkeen. Seuraava 'käsky' -osoitteen (eli taulukon merkinnän) laskeminen voidaan suorittaa jopa jokaisen yksittäisen taulukon merkinnän valinnaisena lisätoimintona, joka sallii silmukoiden ja / tai hyppykäskyjen missä tahansa vaiheessa.

Valvontataulukon suorituksen seuranta

Tulkkiohjelma voi valinnaisesti tallentaa ohjelmalaskurin (ja muut asiaankuuluvat yksityiskohdat käskytyypistä riippuen) kussakin vaiheessa tallentaakseen täydellisen tai osittaisen jäljen todellisesta ohjelmavirrasta virheenkorjausta , hot spot -havaintoa, koodin peittoanalyysiä ja suorituskykyanalyysiä varten (katso esimerkkejä CT3 ja CT4 yllä).

Edut

  • selkeys - Tiedotus taulukot ovat läsnä kaikkialla ja enimmäkseen luontaisesti ymmärtänyt edes jota yleisö (erityisesti vianmääritystarkoituksia taulukot tuoteoppaita )
  • siirrettävyys - voidaan suunnitella 100% kielestä riippumattomaksi (ja alustasta riippumattomaksi - paitsi tulkki)
  • joustavuus - kyky suorittaa joko primitiivit tai aliohjelmat läpinäkyvästi ja räätälöidä ongelman mukaan
  • kompakti - taulukko näyttää yleensä ehtojen / toimintojen pariliitoksen vierekkäin (ilman tavallisia alustan / kielen toteutusriippuvuuksia), mikä johtaa usein myös
    • binaaritiedosto - kokoa pienennetään vähentämällä ohjeiden kopiointia
    • lähdetiedosto - pienennetään poistamalla useita ehdollisia lauseita
    • parannettu ohjelman lataus (tai lataus) nopeus
  • ylläpidettävyys - taulukot vähentävät usein ylläpidettävien lähdelinjojen määrää v. useita vertailuja
  • viittauksen sijainti - kompaktit taulukkorakenteet johtavat siihen, että taulukot jäävät välimuistiin
  • koodin uudelleenkäyttö - "tulkki" on yleensä uudelleenkäytettävä. Usein se voidaan helposti mukauttaa uusiin ohjelmointitehtäviin täsmälleen samaa tekniikkaa käyttäen ja se voi kasvaa "orgaanisesti", jolloin siitä tulee käytännössä testattujen ja testattujen alirutiinien standardikirjasto , jota ohjaavat taulukon määritelmät.
  • tehokkuus - mahdollinen järjestelmänlaajuinen optimointi. Mikä tahansa tulkin suorituskyvyn parantaminen parantaa yleensä kaikkia sitä käyttäviä sovelluksia (katso esimerkkejä yllä olevasta CT1: stä).
  • laajennettavissa - uusia "ohjeita" voidaan lisätä - yksinkertaisesti laajentamalla tulkki
  • tulkki voidaan kirjoittaa kuten sovellusohjelma

Vaihtoehtoisesti: -

  • tulkki voi olla sisäänpäin kääntyneitä ja "itse optimoida " käyttämällä ajonaikaisen mittareita kerätään itse taulukko (ks CT3 ja CT4 - joissa merkinnät, joita voitaisiin määräajoin lajiteltu laskeva määrä). Tulkki voi myös valita tehokkaimman hakutekniikan dynaamisesti ajon aikana kerätyistä tiedoista (esim. Taulukon koko, arvoalue, lajiteltu tai lajittelematon)
  • dynaaminen lähetys - yhteiset toiminnot voidaan ladata valmiiksi ja harvinaisemmat toiminnot voidaan hakea vasta ensimmäisellä kohtaamisella muistin käytön vähentämiseksi . Tämän saavuttamiseksi voidaan käyttää muistiinpanoja taulukossa .
  • Tulkissa voi olla sisäänrakennettu virheenkorjaus-, jäljitys- ja monitoriominaisuuksia - jotka voidaan sitten kytkeä päälle tai pois päältä haluamallaan tavalla testi- tai live-tilan mukaan
  • ohjaustaulukot voidaan rakentaa 'lennossa' (joidenkin käyttäjän antamien tietojen tai parametrien perusteella) ja sitten tulkki suorittaa ne (ilman rakennuskoodia kirjaimellisesti).

Haitat

  • koulutusvaatimus - sovellusohjelmoijia ei yleensä kouluteta tuottamaan yleisiä ratkaisuja

Seuraava koskee lähinnä niiden käyttöä moniulotteisissa taulukoissa, ei aiemmin käsiteltyjä yksiulotteisia taulukoita.

  • overhead - lisääntynyt jonkin verran, koska ylimääräinen taso välillisen aiheuttama virtuaalinen ohjeita tarvitse olla 'tulkittava' (tämä kuitenkin voidaan yleensä enemmän kuin kompensoi hyvin suunniteltu geneerinen tulkki täysimääräinen tehokkaan suoran kääntää, etsiä ja ehdollinen testaustekniikoiden jotka saattavat ei ole muuten käytetty)
  • Monimutkaisia lausekkeita ei voida aina käyttää suoraan taulukon merkinnöissä vertailua varten
(nämä 'väliarvot' voidaan kuitenkin laskea etukäteen sen sijaan alirutiinissa ja niiden arvot, joihin viitataan ehdollisen taulukon kohdissa. Vaihtoehtoisesti alirutiini voi suorittaa koko kompleksisen ehdollisen testin (ehdottomana 'toimintona') ja asettamalla totuuslippu tuloksena, se voidaan sitten testata seuraavassa taulukossa. Katso Strukturoidun ohjelman lause )

Lainaukset

Monisuuntainen haarautuminen on tärkeä ohjelmointitekniikka, joka korvataan liian usein tehottomalla if-testien sekvenssillä. Peter Naur kirjoitti minulle äskettäin, että hän pitää taulukoiden käyttöä ohjelmavirran hallitsemiseksi tietotekniikan perusajatteluna, joka on melkein unohdettu; mutta hän odottaa, että se on kypsä löydettäväksi uudelleen joka päivä. Se on avain tehokkuuteen kaikissa parhaimmissa kääntäjissä, joita olen tutkinut.

-  Donald Knuth , jäsennelty ohjelmointi ja siirry lausuntoihin

On toinen tapa tarkastella tulkitsevalla kielellä kirjoitettua ohjelmaa. Sitä voidaan pitää sarjana aliohjelmakutsuja yksi toisensa jälkeen. Tällainen ohjelma voidaan itse asiassa laajentaa pitkäksi sarjaksi kutsuja aliohjelmissa, ja päinvastoin, sellainen sekvenssi voidaan yleensä pakata koodattuun muotoon, joka tulkitaan helposti. Tulkintatekniikoiden etuna ovat esityksen pienikokoisuus, koneen riippumattomuus ja lisääntynyt diagnostiikkakyky. Tulkki voidaan usein kirjoittaa niin, että itse koodin tulkintaan ja haarautumiseen sopivaan rutiiniin kuluva aika on vähäinen

-  Donald Knuth , The Art of Computer Programming, osa 1, 1997, sivu 202

Ohjelman esittämiseen tarvittavaa tilaa voidaan usein vähentää käyttämällä tulkeja, joissa yhteiset toimintosekvenssit on esitetty tiiviisti. Tyypillinen esimerkki on äärellisen tilan koneen käyttö monimutkaisen protokollan tai leksikaalisen muodon koodaamiseksi pieneksi taulukoksi

-  Jon Bentley , Tehokkaiden ohjelmien kirjoittaminen

Hyppypöydät voivat olla erityisen tehokkaita, jos etäisyystestit voidaan jättää pois. Esimerkiksi, jos ohjausarvo on lueteltu tyyppi (tai merkki), se voi sisältää vain pienen kiinteän arvoalueen ja aluetesti on tarpeeton edellyttäen, että hyppytaulukko on riittävän suuri käsittelemään kaikkia mahdollisia arvoja

-  David. SPULER, kääntäjäkoodinmuodostus monitievälitteisille haarakäskyille staattisena hakuongelmana

Ohjelmat on kirjoitettava ihmisten lukemista varten ja vain satunnaisesti koneiden suorittamista varten.

-  "Tietokoneohjelmien rakenne ja tulkinta", esipuhe ensimmäiseen painokseen, Abelson & Sussman

Näytä minulle vuokaaviosi ja piilota taulukosi, niin minä jatkan mysti. Näytä taulukot, enkä yleensä tarvitse vuokaaviota; se on ilmeistä.

-  "Myyttinen ihmiskuukausi: esseitä ohjelmistotuotannosta", Fred Brooks

Katso myös

Huomautuksia

Viitteet

Ulkoiset linkit