Ez a fogalom azt jelenti, hogy beállíthatjuk egy mau függvény automatikus, időzített végrehajtását. Azt tehát, hogy az a függvény végrehajtódjon minden X időtartam letelte után, aholis az X milliomodmásodpercekben értendő. Továbbá, ez az időtartam „közelítőleg” értendő.
Azért „megközelítőleg” csak, mert aritmetikai vagy stringkifejezés kiértékelését nem hagyja félbe emiatt a „rencer”. Hanem minden egyes új mau utasítás végrehajtása előtt vizsgálja meg, van-e teendője ilyen téren. Ezokból természetesen az időzítés nem lesz abszolút pontos, de szerintem amire egy interpreteres nyelvnek kell, ami nem valósidejű folyamatvezérlésre van kitalálva, arra a célra teljesen jó.
Sajnos azonban, ennek ára van! A dolog ugyebár a gép belső órájának lekér
dezésén alapszik, amit a clock() függvénnyel kérdezek le. És ezt biza lekérdezi őkelme minden egyes utasításvégrehajtáskor! És ilyenkor elvégez egy kivonást is és egy összehasonlítást. Ezen extra teendők miatt a programvégrehajtás ideje tapasztalataim (=méréseim) szerint az ÖTSZÖRÖSÉRE nőtt (!!!!!!!), sőt, elő
fordulhat akár a tízszeres lassulás is egyes feladatoknál. Szerencsére tényleg csak azon esetekben amikor ez az interrupt dolog be van kapcsolva nála. (Nyilvánvaló ugyanis hogy ez ki-be kapcsolgatható egy utasítással).
Szóval, ésszel kell használni mert nagyon lelassítja a futást.
A szintaxis:
ii 0;
vagy
ii;
E két fenti utasítás KIKAPCSOLJA a megszakításvégrehajtást. Az ii; variációban a pontosvessző előtt nem állhat whitespace!
ii „S”;
vagy
ii [sorszám];
A fenti szintaxissal adhatjuk meg, melyik függvényt nevezzük ki interrupt
rutinnak. A függvény maga teljesen ugyanúgy nézhet ki, mint bármely közönsé
ges mau függvény, semmi extra dolgot nem kell beleírni ahhoz hogy interruptként használhassuk, egyetlen kikötés, hogy nem várhat el input paramétereket, és nem adhat vissza eredményeket. Azaz, e függvény vezérlését globális változókon át kell megoldanunk, vagy az „álfüggvények”-ről szóló részben leírtak szerint kell birizgálnunk a változóit.
A fenti szintaxisnál az S egy stringkifejezés lehet ami az interruptfüggvény nevét határozza meg, illetve a sorszám egy olyan aritmetikai kifejezés mely a függvény sorszámát mondja meg. Mindenben olyan ez is tehát mint amikor egy függvényt meghívnánk. Fontos tudni, hogy hiába adjuk meg név szerint a függvényt, ezt a drága átkonvertálja sorszámmá és a sorszámot tárolja el, emiatt rém rossz ötlet egy bekapcsolt interrupt során betölteni újabb mau függvényeket, mert mint tudjuk olyankor azok névsorba lesznek rendezve, s így előfordulhat hogy megváltozik egy függvény sorszáma...
Az interrupt elindítása:
ii x
Ahol az x egy mau_g azaz #g típusú aritmetikai kifgejezés lehet, ez határozza meg, hogy hány milliomod másodpercenként hajtódjon végre. Ha ezen érték 0, akkor az KIKAPCSOLJA az interruptot (de ettől még a beállított interruptfüggvény NEVÉT, pontosabban a SORSZÁMÁT nem felejti el, azt nem kell újra beállítani egy újabb bekapcsolás előtt).
Mindenféleképpen előbb az interruptfüggvény nevét vagy sorszámát adjuk meg a legelső bekapcsolás előtt, különben automatikusan a nullás sorszámú függvényt óhajtja meghívni, ami legtöbbször a főprogram maga. De ha mégsem az, akkor is véletlenszerű hogy mi, ha nem állítottuk be...
Továbbá, az interruptfüggvény nem fogja magát meghívni interruptként, azaz, amíg az interruptfüggvényt hajtja végre, addig kikapcsolja az interruptot ideiglenesen... Nem fordulhat elő tehát olyan helyzet, hogy mert az interrupt
függvény végrehajtása túl soká tart, azt félbehagyja és újrakezdi. Ezenfelül garantált, hogy az interruptfüggvény lefutása után mindenféleképpen végrehajt legalább egyetlen olyan utasítást, ami nem az interruptfüggvényhez tartozik.
Természetesen az interruptfüggvény is emlékszik a korábbi futásai során kikalkulált eredményeire, változóinak értékeire.
Íme egy példa a használatára:
#!mau
#c@„"Interrupt"”c=a;
ii „"Interrupt"”;
ii 200000;
// kiszámoljuk a pit a leibniz formulával.
#t@a; // inicializálunk egy időváltozót
#d@p=0; // Az osszegvaltozo
#L@n=1; // A nevezo
#L@s=1; // A szamlalo {| 3000000
#d@p= (@p) + (#L@s)/(#L@n);
#L@n = (@n) + 2;
#L@s = -1*(@s);
|}
#t@b; // inicializálunk egy másik időváltozót
#g@x=(#t@b)-(#t@a);
"Idő: " ?g @x; /;
#d@p = 4*#d@p;
"Pi/4 közelítés: " ?d @p; /;
"Vége!\n"
ii;
XX
„Interrupt” // Interruptrutin
?k #c@c; /;
#c++@c;
xx
Megjegyzem, szándékosan nem a leghatékonyabb pí-számító rész van e fenti példába beletéve, hogy tovább tartson. Az eredménye:
a
Azaz mint látható, miközben számolja ki a pí közelítését a főprogramban, időn
ként meghívja az „Interrupt” nevű függvényt, ami olyankor kiír egy újabb karak
tert a képernyőre. Amennyiben e programot kipróbálod a saját gépeden, simán lehetséges hogy a kiírt betűk száma több vagy kevesebb lesz, mert ez attól függ, milyen gyors a számítógéped.
Általában efféle interruptokra „emberileg észlelhető” időtartamokon beül van szükségünk, például egy szövegkurzor villogtatásához. Ez úgy nagyjából tized
másodperces időtartam. Ennyi idő alatt a számítógép eszméletlenül sok mau uta
sítást képes lenne feldolgozni, és teljesen felesleges hogy mindegyik alkalommal lekérdezze a gép aktuális idejét, ez csak feleslegesen lassítaná a programfutást.
Ezért van rá lehetőségünk, hogy megadjuk neki, hány mau utasítás végrehajtása után ellenőrizgesse csak, hogy letelt-e a beállított időtartam! Ez az II utasítással történik. Szintaxisa:
II x
Ahol az x egy unsigned int típusú kifejezés. Ezzel kiegészítve az előbbi program így néz ki:
// kiszámoljuk a pit a leibniz formulával.
#t@a; // inicializálunk egy időváltozót
#t@b; // inicializálunk egy másik időváltozót
#g@x=(#t@b)-(#t@a);
"Idő: " ?g @x; /;
#d@p = 4*#d@p;
"Pi/4 közelítés: " ?d @p; /;
"Vége!\n"
ii;
XX
„Interrupt” // Interruptrutin
?k #c@c; /;
#c++@c;
xx
Az eredménye:
a b c d e
Idő: 1058851
Pi/4 közelítés: 3.14159 Vége!
Szépen felgyorsult az ötszörösére, attól az
II 1000
sortól...