M A S A R Y K O V A UNIVERZITA
FAKULTA INFORMATIKY
Integrace skriptovacích jazyků
do C++ kódu
D I P L O M O V Á PRÁCE
Michal Pochobradský
Brno, jaro 2016
Místo tohoto listu vložte kopie oficiálního podepsaného zadání práce a prohlášení
autora školního díla.
Prohlášení
Prohlašuji, že tato diplomová práce je mým původním autorským
dílem, které jsem vypracoval samostatně. Všechny zdroje, prameny
a literaturu, které jsem při vypracování používal nebo z nich čerpal,
v práci řádně cituji s uvedením úplného odkazu na příslušný zdroj.
Michal Pochobradský
Vedoucí práce: RNDr. Dalibor Klusáček, Ph.D.
i
Poděkování
Chtěl bych zde poděkovat svému vedoucímu práce RNDr. Daliboru
Klusáčkovi, Ph.D. za čas, vstřícnost a mnoho rad jež mi dal. Dále bych
chtěl poděkovat Mgr. Václavu Chlumskému a RNDr. Simonu Tóthovi
za mnoho rad a technickou pomoc s plánovačem systému TORQUE.
Nakonec bych chtěl též poděkovat svým rodičům za nezměrnou podporu
při mém studiu.
iii
Shrnutí
Cílem této práce je popsat a porovnat způsoby integrace různých
skriptovacích jazyků do C/C++ aplikace. K porovnání byly zvoleny
jazyky ChaiScript, Python, Lua a JavaScript. Pro každý z nich je popsán
přesun hodnot mezi skriptovacím jazykem a C/C++ kódem,
volání funkcí a export datových typů z C/C++. Součástí práce je též
porovnání výkonu jednotlivých jazyků při volání funkcí a exportu dat.
Získané znalosti jsou pak použity k praktické ukázce možného využití
skriptovacího jazyka v plánovači dávkového systému TORQUE.
iv
Klíčová slova
skriptovací jazyky, integrace, C/C++, ChaiScript, Python, Lua, JavaScript,
V8, SpiderMonkey
v
Obsah
1 Úvod 1
2 Testované jazyky 3
2.1 ChaiScript 4
2.1.1 Instalace a inicializace 4
2.1.2 Správa paměti 5
2.1.3 Export jednoduchých hodnot do scriptu 5
2.1.4 Export jednoduchých hodnot ze scriptu 5
2.1.5 Export C++ funkcí do scriptu 5
2.1.6 Volání funkcí z C++ 6
2.1.7 Export C komplexních typů 6
2.2 Python 7
2.2.1 Instalace a inicializace 7
2.2.2 Správa paměti 8
2.2.3 Export jednoduchých hodnot do scriptu 9
2.2.4 Export jednoduchých hodnot ze scriptu 9
2.2.5 Export C++ funkcí do scriptu 10
2.2.6 Volání funkcí z C++ 11
2.2.7 Export C komplexních typů 11
2.3 Lua 14
2.3.1 Instalace a inicializace 14
2.3.2 Správa paměti 15
2.3.3 Export jednoduchých hodnot do scriptu 15
2.3.4 Export jednoduchých hodnot ze scriptu 16
2.3.5 Export C++ funkcí do scriptu 16
2.3.6 Volání funkcí z C++ 17
2.3.7 Export C komplexních typů 18
2.4 JavaScript V8 20
2.4.1 Instalace a inicializace 20
2.4.2 Správa paměti 21
2.4.3 Export jednoduchých hodnot do scriptu 22
2.4.4 Export jednoduchých hodnot ze scriptu 22
2.4.5 Export C++ funkcí do scriptu 22
2.4.6 Volání funkcí z C++ 23
2.4.7 Export C komplexních typů 24
2.5 JavaScript SpiderMonkey 27
vii
2.5.1 Instalace a inicializace 27
2.5.2 Správa paměti 28
2.5.3 Export jednoduchých hodnot do scriptu 29
2.5.4 Export jednoduchých hodnot ze scriptu 29
2.5.5 Export C++ funkcí do scriptu 29
2.5.6 Volání funkcí z C++ 30
2.5.7 Export C komplexních typů 31
2.6 Správa paměti obecně 33
2.7 Podpůrné nástroje 34
2.7.1 SWIG 35
2.7.2 BOOST.PYTHON 36
2.7.3 LuaWrapper 37
2.7.4 Cython 38
3 Měření výkonu 41
3.1 Vyvolání exportované funkce 41
3.2 Rychlost paměťového přenosu 43
3.3 Rychlostfunkce definované ve skriptu 44
4 Osobní zkušenosti a celkové vyhodnocení 47
4.1 ChaiScript 47
4.2 Python 48
4.3 Lua 48
4.4 JavaScript V8 49
4.5 JavaScript SpiderMonkey 49
5 Plánovač 51
5.1 Rozšíření konfigurace plánovače 51
5.1.1 Dynamické načítání konfigurace 51
5.1.2 Rozšíření konfigurace 51
5.1.3 Získané zkušenosti 52
5.2 Integrace skriptovacího jazyka 53
6 Závěr 55
A Obsah přiloženého DVD 59
A . l Výkonostní testy 59
A . l . l práce_s_pametí_a_volání_skriptu.ods 59
A. 1.2 volání_exportovných_funkcí.ods 59
A.2 Úpravy plánovače 59
A.2.1 troque_fast_sched-git.txt 59
A.2.2 js_v8.cpp 59
A.2.3 js_v8.hpp 59
viii
A.2.4 plan_eval.js 60
ix
1 Úvod
Cílem této práce je prozkoumat možnosti spolupráce skriptovacích
jazyků a C/C++ kódu s ohledem na možnost rozšíření konfigurace
plánovače systému TORQUE (dále jen plánovač), který je využíván pro
plánování výpočetních úloh na strojích zapojených do distribuované
výpočetní infrastruktury centra CERIT-CS [3].
Dávkový systém TORQUE propojuje zapojené zdroje (počítače,
datová úložiště apod.) a umožňuje jejich sdílení, takže uživateli stačí
do systému zadat úlohu a už se nemusí starat o to, kde se úloha
vykoná. TORQUE má tři části. První je server, na nějž uživatelé posílají
úlohy, které server rozesílá klientům (viz dále), a od něj uživatelé
dostávají výsledky. Druhou jsou klienti, kteří jsou nainstalováni na
strojích počítajících úlohy. Třetí částí je plánovač, který dostává od
serveru informace o úlohách a nazpět posílá pokyny, kdy a kde se mají
jednotlivé úlohy vykonat. Právě konfigurace plánovače je motivací
této práce.
Plánovač používá pro uložení konfigurace textové soubory s jednoduchým
formátem umožňujícím nastavit hodnoty konfiguračních
voleb. Takováto konfigurace se ovšem ukazuje jako nedostatečná, neboť
aby se dosáhlo požadovaných možností konfigurace, bylo by občas
nutno přidat zcela neúměrně mnoho konfiguračních voleb pro
kontrolu malé části kódu. Lepší by bylo přímo upravit kód daného
algoritmu, ovšem to v současnosti znamená znovu zkompilovat celý
plánovač. Možným řešením by byla integrace interpretu nějakého
skriptovacího jazyka do plánovače a přesunutí často upravovaného
algoritmu do skriptu. Použití skriptu by mělo umožnit požadovanou
volnost při konfiguraci, protože by díky tomu by bylo možné za běhu
plánovače měnit celý takto exportovaný algoritmus, a ne jen jeho vybrané
parametry. Integrovaný interpret by umožnil vykonat vždy
aktuální skript s daným algoritmem bez nutnosti jakékoliv kompilace.
Integrace skriptovacího jazyka do existující C/C++ aplikace však
není triviální. V této práci popíšu a porovnám postupy, jak ve vybraných
skriptovacích jazycích umožnit spolupráci s C/C++ kódem, a
poukážu na možné problémy s tímto související.
Možnost integrace skriptovacího jazyka do plánovače ukážu exportem
vybraného algoritmu do zvoleného skriptovacího jazyka. K tomu
1
i . ÚVOD
a ke zohlednění potřeb plánovače se budu muset napřed seznámit
s plánovačem a jeho konfigurací. Proto rozšířím možnosti jeho současné
konfigurace.
Existuje mnoho potenciálně použitelných jazyků a bylo by nemožné
otestovat všechny, proto jsme se v diskusi s vedoucím práce a
vývojáři plánovače dohodli na následujících čtyřech. Prvním je ChaiScript,
který by měl být snadno integrovatelný do C/C++ kódu. Druhým
je široce používaný Python. Třetím je Lua, která je také často
používaná pro integraci do C/C++ aplikací. Čtvrtým je JavaScript,
jehož interprety se stali staly důležitou součástí internetových prohlížečů,
a dočkal se tak závodů v rychlosti interpretů. Pro JavaScript
jsme zvolili dvě implementace interpretu ze dvou nejrozšířenějších
prohlížečů s otevřenými zdrojovými kódy. Prvním je V8 engine od
firmy Google, který je použit v prohlížeči Chromé. Druhým je pak
SpiderMonkey použitý v prohlížeči Firefox.
V následujícím textu nejprve představím C/C++ rozhraní jednotlivých
jazyků. Dále uvedu porovnání výkonnosti těchto jazyků ve
vybraných oblastech. Poté uvedu provedu celkové zhodnocení jednotlivých
jazyků. Nakonec popíšu změny, jež jsem provedl v plánovači,
abych se s ním seznámil, a ukázku integrace zvoleného skriptovacího
jazyka.
2
2 Testované jazyky
V této kapitole se zaměřím na prostředky spolupráce zvolených skriptovacích
jazyků s C/C++. Při vytváření rozhraní mezi C/C++ a moderním
skriptovacím jazykem vyvstávají zejména dva problémy Zaprvé
skriptovací jazyky jsou dynamicky typované, zatímco C/C++ je staticky
typovaný jazyk. Tento rozdíl lze zpravidla řešit a skriptovací jazyky
(přinejmenším ty jimiž se zabývám v této práci) poskytují C/C++
rozhraní umožňující toho dosáhnout. Zpřístupnit data z C/C++ pro
použití ve skriptovacím jazyku a naopak je už zpravidla relativně
jednoduchý, ačkoliv často rozsáhlý úkol.
Druhým problémem při exportu je alokace a dealokace paměti,
která je v C/C++ zcela v rukou programátora, ale skriptovací jazyky
používají tzv. Garbage Collector (dále jen GC), tedy otázkou je, kdo
má uvolnit paměť exportovaných hodnot. Tento problém je typicky
složitější, proto se jím v následujícím textu nebudu zaobírat a budu
mu věnovat samostatnou podkapitolu později (viz kapitola 2.6).
V následujících podkapitolách každý jazyk krátce představím a
pro každý ukážu:
• Jak daný jazyk připravit pro použití.
• Jak pracovat s pamětí drženou daným jazykem.
• Jak převést jednoduchou hodnotu (např. číslo) z daného skriptovacího
jazyka do C/C++ a naopak.
• Jak z daného skriptovacího jazyka volat C/C++ funkce a nao­
pak.
• Jak exportovat složité C / C++ pole a třídy. Jak uvádím v kapitole
5.1, v plánovači jsou často používány C/C++ struktury1
, budu
se jim proto věnovat více.
Ještě upozorním, že cílem dalšího textu je pouze ukázat, že výše
uvedené cíle jsou dosažitelné, a popsat postup, jak jich dosáhnout, ale
samozřejmě mohou existovat i jiné postupy.
1. v C++ představují datové typy, struktura struct a třída class prakticky totéž
3
2. TESTOVANÉ JAZYKY
2.1 ChaiScript
ChaiScript [11] je relativně mladý jazyk (stabilní verze od roku 2009),
jeho asi nejvýraznější vlastností je velký důraz na snadnou integraci
s C/C++ kódem. To se projevuje jak v jeho C/C++ rozhraní, tak i v syntaxi
samotného skriptu, která se zjevně inspiruje syntaxí jazyka C.
2 //inicializace
3 chaiscript::ChaiScript chai;
4
5 //export proměnné
6 int a = 2;
7 chai.add(chaiscript::var(a),"A");
8 //ziskáni hodnoty z ChaiScriptu
9 int a = chai.eval<int>("A");
10 //stejně jednoduše lze do ChaiScriptu exportovat funkce
11 double foo (double i){
12 return 42;
13 >
14 chai.add(chaiscript::fun(foo), "foo");
Ukázka 2.1: ChaiScript jednoduchá ukázka: inicializace, export
proměnné a funkce do ChaiScriptu a vrácení hodnoty z ChaiScriptu
2.1.1 Instalace a inicializace
ChaiScript není potřeba instalovat ani zvlášť kompilovat, stačí do kódu
přidat include jeho hlavičkových souborů (viz [11]). V této práci používám
ChaiScript verze 5.7.
Použití jazyka ChaiScript z C++ je velmi přímočaré, k základní
inicializaci stačí vytvořit instanci třídy ChaiScript (viz Ukázka 2.1 ř.
3, konstruktoru třídy lze předat jako parametr modul s knihovnou,
případně cesty, kde hledat skripty), od tohoto okamžiku je ChaiScript
připraven k použití. Skript k vykonání lze ChaiScriptu předat buď
jako textový řetězec pomocí metody evalQ (viz Ukázka 2.1 ř. 9), nebo
jako soubor pomocí metody eval_file().
4
2. TESTOVANÉ JAZYKY
2.1.2 Správa paměti
ChaiScript interně používá kopie, pouze pokud je cokoliv exportováno
jako ukazatel nebo reference (ať už z C do ChaiScriptu, tak z
ChaiScriptu do C/C++), tak je na programátorovi, aby zajistil, že odkazovaná
paměť nebude předčasně uvolněna, toto může zjednodušit
použití sdílených ukazatelů ze standardu C++11, které ChaiScript
podporuje stejně jako ukazatele běžné.
2.1.3 Export jednoduchých hodnot do scriptu
K exportu proměnných do ChaiScriptu slouží dvouparametrická verze
metody add(), které se předá exportovaná proměnná zabalená pomocí
funkce var{) a textový řetězec obsahující jméno, pod nímž bude proměnná
vystupovat ve skriptu (viz Ukázka 2.1 ř. 7). Stojí za povšimnutí,
že není třeba zadávat datový typ proměnné, ten se určí automaticky.
Zadávaná proměnná může být také ukazatel nebo reference.
2.1.4 Export jednoduchých hodnot ze scriptu
K získání hodnot ze skriptu slouží metoda eval(), která vykoná předaný
script a vrátí výsledek. Datový typ očekávaného výsledku lze
zadat jako parametr šablony (viz Ukázka 2.1 ř. 9), pokud žádný typ
není zadán, vrátí funkce výsledek jako třídu BoxedValue, což je C++
datový typ, který ChaiScript interně používá pro všechny hodnoty Pro
získání hodnoty konkrétní proměnné ze skriptu stačí metodě evalQ
jako parametr předat název této proměnné.
2.1.5 Export C++ funkcí do scriptu
Export C++ funkce do skriptu se v zásadě neliší od exportu proměnné,
pouze je třeba exportovanou funkci zabalit pomocí funkce fun() místo
var() (viz Ukázka 2.1 ř. 14), parametry ani návratovou hodnotu není
třeba nijak specifikovat.
5
2. TESTOVANÉ JAZYKY
2.1.6 Volání funkcí z C++
Úplně stejně jako proměnné lze z ChaiScriptu získat i funkce, návratovou
hodnotou metody eval() je v tomto případě C++11 šablona
stá :: function, konverze jejích argumentů proběhne automaticky.
2.1.7 Export C komplexních typů
Zde popíšu, jak lze exportovat C/C++ pole a třídy. Jen pro úplnost
uvedu, že přesná definice třídy TestClass používané v ukázkách jako
exportovaná C++ třída je součástí přiložených testů (viz přílohy A.l).
Při exportu C/C++ třídy je třeba si uvědomit, že ChaiScript stejně
jako jakýkoliv jiný jazyk nezná konkrétní exportovanou třídu, proto je
třeba ji napřed zaregistrovat. Poněkud překvapivější by mohlo být, že
jednoduše nelze exportovat ani C/C++ pole. Jenže běžně používaná
pole ve většině skriptovacích jazyků, včetně ChaiScriptu, nejsou zcela
ekvivalentní C/C++ poli, například jsou dynamická a typicky mohou
obsahovat hodnoty různého typu.
1 //registrace pole 3 hodnot typu int jako IntArray3
2 chai.add(bootstrap::array<int[3]>("IntArray3"));
3 //registrace vektoru hodnot typu int jako Veclnt
4 chai.add(
bootstrap::standard_library::vector_type<std::vector<int>
>("VecInt"));
5 //vytvořeni modulu
6 chaiscript::ModulePtr m = chaiscript::ModulePtr(new
chaiscript::Module());
7 //registrace třidy TestClass
H chaiscript::utility::add_class<TestClass>(*m,
9 "TestClass",//jméno v ChaiScriptu
10 {//seznam konstruktorů k zaregistrováni
chaiscript::constructor<TestClass(int,int,int,int)>(),
12 chaiscript::constructor<Base(const TestClass&)>()
13 },//seznam metod k zaregistrováni
{{chaiscript::fun(&TestClass::metod), "metod"}});
15 //načteni modulu
16 chai. add(m);
Ukázka 2.2: ChaiScriptu, registrace komplexních typů
6
2. TESTOVANÉ JAZYKY
Pole Pro export polí je třeba v ChaiScriptu nejprve zaregistrovat typ
exportovaného pole, to se provede pomocí pomocné funkce array{) a
výsledek této metody se do ChaiScriptu přidá pomocí jednoparametrické
verze metody add() (viz Ukázka 2.2 ř. 2).
Po zaregistrování se již pole exportují stejně jako jakákoliv jiná hodnota.
Ještě upozorním, že pole se registruje včetně své velikosti, různě
velká pole stejného typu je tak potřeba registrovat zvlášť. Obdobně se
exportují i standardní C++ kontejnery (viz Ukázka 2.2 ř. 4).
Třídy Pro export vlastních tříd je nejjednodušší vytvořit si nový
modul a použít pomocnou funkci add_class(), která zaregistruje do
daného modulu třídu, její konstruktory a metody (viz Ukázka 2.2 ř.
6-16), alternativně lze totéž udělat tak, že se zaregistruje typ obdobně
jako proměnná2
a poté se zaregistrují jednotlivé metody a konstruktory
(metody i atributy třídy se registrují jako funkce).
2.2 Python
Python patří k nejznámějším a nejpoužívanějším skriptovacím jazykům.
Díky jeho již dlouhodobému vývoji (vyvíjen od roku 1990) má
odladěnou C/C++ implementaci zvanou CPython se stabilním C/C++
rozhraním.
2.2.1 Instalace a inicializace
V této práci používám Python (verze 3.4), který je dostupný z webu[6].
Alternativně je možné na Ubuntu a zřejmě i jiných linuxových distribucích
nainstalovat potřebnou knihovnu a hlavičkové soubory z
repositářů. Pro jeho použití z C/C++ kódu je třeba přidat hlavičkový
soubor Python.h a přilinkovat jeho knihovnu.
Inicializace proběhne opět velmi jednoduše, tentokrát zavoláním
funkce Py_Initialize(). Pro ukončení a uvolnění zdrojů slouží naopak
funkce Py_Finalize().
Po Py_Initialize() je již Python připraven k použití, ale pro plnohodnotnou
práci je často třeba importovat moduly s dodatečnou funk-
2. pomocí šablony user_type, např. chai.add(user_type < TestClass > (),
"TestClass");
7
2. TESTOVANÉ JAZYKY
cionalitou, toto lze provést pomocí funkce PyItnport_ItnportModule
(viz ř. 6 z Ukázky 2.3), funkce je ekvivalentní příkazu import v jazyce
Python a lze tedy zároveň použít k načtení skriptu z předdefinovaných
cest, ale pro načtení a provedení skriptu poskytuje poskytuje
rozhraní Pythonu též několik vhodnějších funkcí, například
PyRun_SimpleString() (načtení skriptu z textového řetězce) a PyRun_
SimpleFile (načtení skriptu ze souboru).
1 //inicializace Pythonu
2 Py_Initialize();
3 //zde již je inicializace hotová a s Pythonem lze pracovat
4
5 //import dodatečných modulů
6 PyObject *m = PyImport_ImportModule("NazevModulu");
7 //export proměnné
s int a
9 //konverze C hodnoty na hodnotu jazyka Python
10 PyObject *value = PyLong_FromLong(a);
n
12 //nastaveni konvertované hodnoty jako globálni proměnná modulu
m
13 PyObject_SetAttrString(m, ,value)
14 //ziskáni hodnoty z Pythonu
15 PyObject *value2 = PyObject_GetAttrString(m,"A");
u, i f (PyLong_Check(value2)) {
17 a = PyLong_AsLong(value2);
18 }
19 //sniženi referenci již nepoužívaných hodnot
20 Py_DECREF(value);
21 Py_DECREF(value2);
22 //ukončeni práce s Pythonem
23 Py_Finalize();
Ukázka 2.3: Python jednoduchá ukázka: inicializace, export proměnné
do Pythonu a zpět a ukončení práce
2.2.2 Správa paměti
Při používání C rozhraní Pythonu je třeba mít na paměti, že Python
používá pro detekci nepoužívaných proměnných počítání referencí,
8
2. TESTOVANÉ JAZYKY
proto je třeba při používání funkcí manipulujících s nativními hodnotami
jazyka Python, tj. těch, které mají v C typ PyObject, dávat
pozor, jak se chovají k jejich referencím (toto je vždy popsáno v dokumentaci
[7] konkrétní funkce), proto je třeba v případě potřeby počet
referencí snížit, nebo zvýšit (funkcí Py_DECREF() a Py_INCREF(),
pro detaily odkážu na dokumentaci [7]). Zejména je třeba vždy po získání
hodnoty s novou referencí opět snížit počet referencí (viz Ukázka
2.3 ř. 20) poté, co již není potřeba, jinak by jimi držená paměť nemohla
být uvolněna.
2.2.3 Export jednoduchých hodnot do scriptu
Python má vlastní typy (pojmenovány jako Py[Typ], např. PyLong),
které často přibližně odpovídají typům z C, hodnoty těchto typů jsou C
struktury reprezentovatelné jako PyObject (mají definovanou hlavičku
viz kapitola 2.2.7). C rozhraní Python nabízí funkce pro konverzi jednoduchých
C typů na odpovídající PyObject, tyto funkce mají typicky
název tvaru [python typ]_from[C typ] () (viz Ukázka 2.3 ř. 10), jinou
možností je funkce Py_BuildValue{), která bere na vstupu formátovací
řetězec a proměnný počet C hodnot (musí odpovídat formátovacímu
řetězci) a vrátí odpovídající PyObject, takto lze vytvořit i proměnné
složitějších základních typů jazyka Python jako pole nebo seznamy
(pro detaily odkážu na [7]). Hodnoty vrácené těmito funkcemi mají
vždy novou referenci.
Do skriptu je možné tyto hodnoty předat buď jako parametry
funkce, nebo nastavit jako atributy nějakého objektu (např. modulu,
pak takovéto proměnné vystupují jako globální proměnné modulu,
viz Ukázka2.3 ř. 13).
2.2.4 Export jednoduchých hodnot ze scriptu
Ze skriptu lze získat hodnoty jako PyObject jednak jako návratové
hodnoty po volání pythonové funkce (viz 2.2.6), nebo jako atribut jiného
PyObjektu (např. modulu) pomocí PyObject_GetAttrString (viz
Ukázka 2.3 ř. 15))
Ke konverzi z hodnot typu PyObject na C hodnoty slouží funkce
s názvy tvaru [python typ]_as[C typ](), daný PyObject samozřejmě
9
2. TESTOVANÉ JAZYKY
musí být daného typu, toto lze ověřit funkcemi s názvem tvaru [python
typ]_Check() (Ukázka 2.3 ř. 16).
2.2.5 Export C++ funkcí do scriptu
1 //Přímo exportovateIná funkce
2 PyObject *python_function(PyObject *self, PyObject *args){
3 //Získaní argumentu
PyArg_ParseTuple(args, "formátovací řetězec", &argl, . . . ) ;
5 ...
6 }
7 //definice exportu funkcí
s PyMethodDef module_methods[] = {
9 //jméno v Pythonu, funkce, očekávané argumenty, popis
10 {"foo", python_function, METH_VARARGS, "Popis funkce"},
{NULL}
n > ;
i3 static PyModuleDef module = {
PyModuleDef_HEAD_INIT,//nezbytná hlavička modulu
15 " JmenoModulu",
16 "Popis modulu.",
-1,
i8 module_methods
« >;
20 PyModule_Create (femodule);
Ukázka 2.4: Python export C/C++ funkce
Do Pythonu lze přidat funkce např. pomocí modulů, ale nelze přidat
libovolnou funkci, pro export běžné C/C++ funkce je třeba vytvořit
novou funkci splňující níže uvedené, která konvertuje parametry a
zavolá exportovanou funkci.
Nový modul lze vytvořit voláním funkce PyModule_Create() (viz
Ukázka 2.4 ř. 20), pro kterou je třeba vytvořit definici modulu, do
nějž se předá pole definic metod ukončené NULL(viz Ukázka 2.4
ř. 8 až ř. 19, jen poznamenám, že —1 v definici modulu je zde zcela
nepodstatná, pro detaily odkážu na dokumentaci[7]).
Přidávaná funkce musí mít 1 (PyNoArgsFunction), 2 (PyCFunction)
nebo 3 (PyCFunctionWithKeywords) argumenty typu PyObject* (první
10
2. TESTOVANÉ JAZYKY
argument je objekt, na kterém je funkce volána, druhý pozičně zadané
argumenty funkce a třetí jsou argumenty zadané klíčovými slovy) a
vracet PyObject* (viz Ukázka 2.4 ř. 2). Argumenty jsou funkci předány
jako n-tice (Tuple) a k jejich konverzi na C hodnoty slouží funkce
PyArg_ParseTuple(), která konvertuje jednotlivé hodnoty z n-tice na
odpovídající C hodnoty podle formátovacího řetězce ([7, Parsing arguments
and building values]).
2.2.6 Volání funkcí z C++
K vyvolání funkce je třeba nejprve získat funkci jako volatelný PyObject
(viz kapitola 2.2.4), pak stačí použít např. funkci PyObject _CallObject()
(viz. Ukázka 2.5) jejímž prvním argumentem je právě volatelný objekt,
druhým argumenty jako n-tice (Tuple)(pro detaily viz dokumentace
[7]). Opět vrací novou referenci.
i PyObject *result = PyObject_CallObject(py_func, py_args);
Ukázka 2.5: Volání funkce jazyka Python
2.2.7 Export C komplexních typů
Oproti ChaiScriptu Python nemá možnosti, jak jednoduše zadefinovat
typ odpovídající C/C++ poli nebo třídě, a tak je celý proces kompliko­
vanější.
Pole Python běžně používá pro reprezentaci pole objekt typu PyList.
Nejjednodušším způsobem konverze pole je tak vytvořit nový list
pomocí PyList_New(), jejímž argumentem je počet prvků nového
listu (slouží k dopředně alokaci paměti), exportované hodnoty postupně
konvertovat na PyObject (viz 2.2.3) a ty přidávat do pole funkcí
PyList_SetItem (viz Ukázka 2.6, případ na ř. 8 odpovídá přiřazení
list[i] = source[í\).
Druhým řešením je exportovat pole jako novou třídu jazyka Python
a definovat pro ni metody getitem a setitem , případně další
(stejné jako při definici vlastního pole ve skriptu, viz např. [15, Speciál
Method Names]).
11
2. TESTOVANÉ JAZYKY
//„source" je exportované pole
int source[count];
//vytvoření nového Listu velikosti „count"
PyObject * l i s t = PyList_New(count);
//hodnoty pole se nakopíruji do Listu
for (unsigned long i=0;i<count;i++) {
PyList_SetItem(list,i,PyLong_fromLong(source [i]));
}
Ukázka 2.6: Python export pole
Třídy Pro export vlastní třídy je třeba definovat nový typ v Pythonu,
který bude reprezentovat exportovanou třídu. K tomu je třeba nejprve
definovat vlastní PyObject, což je C struktura, na jejímž začátku
je makro PyObject_HEAD, které definuje společnou hlavičku pro
všechny PyObject (viz Ukázka 2.7 ř. 2), Python do hlavičky ukládá
informace o objektu, jako je jeho typ a počet referencí. Další položky
struktury mohou být libovolné C/C++ proměnné, které bude nová
třída potřebovat, to může být např. exportovaná C++ třída.
Dále je třeba vytvořit instanci struktury PyTypeObject (viz Ukázka
2.7 ř. 7), ta definuje vlastnosti nového typu. Tato struktura opět začíná
společnou hlavičkou a má mnoho položek jako jméno typu, jeho velikost,
atributy a metody, atributy mohou být definovány i pomocí
tzv. getter a setter funkcí, (viz Ukázka 2.7 ř. 23), které jsou užitečné při
exportu, protože umožňují přistupovat z Pythonu k exportovanému
atributu třídy jako k atributu (jinak by musel být přístup zprostředkován
voláním funkce). Je možné použít stejnou funkci pro přístup
k různým atributům, konkrétní atribut pak funkce pozná pomocí
tzv. „closure", jež se atributu přiřadí při jeho definici. Mnoho z položek
struktury PyTypeObject může být ponecháno jako 0, jejich výpis
a popis by byl příliš dlouhý a asi zbytečný, proto pouze odkážu na
dokumentaci ([7]).
12
2. TESTOVANÉ JAZYKY
1 //definice PyObject struktury exportované třidy
2 typedef struct {
3 PyObject_HEAD
TestClass c_class;
5 } ClassWrapper;
6 //definice typu
7 PyTypeObject ClassWrapperType = {
s PyVarObj ect_HEAD_INIT(NULL, 0)
9 0,
io "clasTest.ClassWrapper",
sizeof(ClassWrapper),
12 ...
13 }
14 //Ukázka hlavičky getteru.
is PyObject* get_a(ClassWrapper * self, void *closure){
16 ...
17 }
is //Ukázka hlavičky setteru.
19 int set_a(ClassWrapper * self, PyObject * value, void
*closure) {
20 . . .
21 }
22 //Pole definic getter a setter funkci
23 PyGetSetDef ClassWrapper_getseters [] = {
24 {"a",//jméno atributu v Pythonu
25 (getter)get_a,
26 (setter) set_a,
27 "Popis atributu A",
28 NULL},//tzv. „ closure"
29 {NULL} //pole je ukončeno pomoci NULL
30 };
31 //připraveni typu a jeho přidáni do modulu
32 PyType_Ready(&ClassWrapperType);
33 PyModule_AddObject(m, "ClassWrapper", (PyObject*)
&ClassWrapperType);
Ukázka 2.7: Python Export třídy
Poté je třeba nový typ připravit k použití funkcí PyType_Ready{) a
přidat do modulu pomocí funkce PyModule_AddObjectQ, jejím prv-
13
2. TESTOVANÉ JAZYKY
ním argumentem je modul (vytvoření nového modulu bylo ukázáno
v kapitole 2.2.5), druhým název typu v modulu a třetím ukazatel na
instanci Px/Tx/peObject popisující nový typ.
2.3 Lua
Lua je podobně jako Python již poměrně starý jazyk (vznikl v roce
1993). Lua je docela často používána v C/C++ aplikacích, několikrát
byla například využita jako integrovaný skriptovací jazyk v úspěšných
počítačových hrách 3
.
2.3.1 Instalace a inicializace
Lua je dostupná z [13], součástí archívu jsou pokyny k instalaci. Pro použití
v C/C++ kódu je třeba přidat hlavičkové soubory lua.h, lualib.h
a lauxlib.h, Lua je kompilovaná jako C knihovna, proto je třeba tyto
soubory vkládat v extern"C" bloku.
Lua používá k předávání hodnot mezi funkcemi zásobník. Položky
zásobníku je možno indexovat zdola (tj. od první přidané) nahoru,
to jsou kladné indexy, nebo shora dolů, to jsou záporné indexy. N a
rozdíl od C v jazyce Lua se indexuje od 1 nikoliv od 0. Zásobník se
předává jako první parametr funkcí z jejího C rozhraní.
Lua často využívá datový typ table, který funguje jako asociativní
pole, a v jazyce Lua je dynamickou obdobou C/C++ třídy či struktury.
K inicializaci stačí vytvořit nový stav funkcí luaL_newstate() a
inicializovat standardní knihovny jazyka Lua (viz Ukázka 2.8 ř. 2 a
4). Ukázka 2.8 opět zachycuje inicializaci, načtení skriptu a předávání
proměnných mezi C a jazykem Lua a v dalším textu se na ni budu
odkazovat.
Pro načtení skriptu ze souboru slouží funkce luaL_loadfile(), která
jej jako funkci uloží na vrchol zásobníku a pro jeho vykonání je třeba
tuto funkci zavolat funkcí lua_pcall() (viz Ukázka 2.8 ř. 6, podrobnosti
o volání funkcí uvádím v kapitole 2.3.6).
3. odkazy na seznamy známých využití jsou dostupné z http: //www. lua. org/
uses.html
14
2. TESTOVANÉ JAZYKY
1 //inicializace
2 L = luaL_newstate();
3 //otevřeni standardních knihoven poté již je inicializace
hotová a s jazykem lze normálně pracovat
4 luaL_openlibs(L);
5 //načteni a vykonáni skriptu
6 luaL_loadfile(L, "soubor_skriptu.lua");
7 lua_pcall(L, 0, 0, 0);
8 int a=l;
9 //nastaveni globálni proměnné
10 lua_pushinteger(L, a);
11 lua_setglobal(L, "A");
12 //ziskáni globálni proměnné
13 lua_getglobal(L, "A");
u a = lua_tointeger(L, 1);
Ukázka 2.8: Lua jednoduchá ukázka: inicializace, načtení skriptu,
export proměnné do jazyka Lua a zpět
2.3.2 Správa paměti
Jak bylo řečeno výše, Lua používá pro ukládání hodnot vlastní zásobník
a všechny ze skriptu dosažitelné hodnoty musí být někde na
zásobníku. Platí, že dokud je hodnota někde na zásobníku, je zachována,
jinak ji může GC kdykoliv odstranit. Toto platí také o textových
řetězcích, proto by se nikdy neměly ukládat ukazatele na textové řetězce
získané ze zásobníku.
2.3.3 Export jednoduchých hodnot do scriptu
Ke konverzi z C hodnot na Lua hodnoty (vložení hodnoty na zásobník)
slouží funkce s názvem tvaru lua_push[Typ](), např. lua_push integer ()
(viz Ukázka 2.8 ř. 10), která zkonvertovanou hodnotu umístí na vrchol
zásobníku. Hodnotu na vrcholu zásobníku lze nastavit jako globální
proměnnou skriptu pomocí funkce lua_setglobal{), pro nastavení hodnoty
atributu objektu slouží funkce lua_setfield().
15
2. TESTOVANÉ JAZYKY
2.3.4 Export jednoduchých hodnot ze scriptu
Pro získání C hodnoty ze zásobníku souží funkce s názvem tvaru
lua_to[typ] ()(viz Ukázka 2.8 ř. 14), její druhou hodnotou je index, na
kterém se v zásobníku daná hodnota nachází. Pro zjištění, zda má
hodnota na zásobníku daný typ, slouží funkce lua_is[typ] (). Hodnotu
globální proměnné lze získat funkcí lua_getglobal, jejímž druhým
parametrem je název proměnné, pro získání hodnoty atributu objektu
slouží funkce lua_getfield().
2.3.5 Export C++ funkcí do scriptu
Lua umožňuje za běhu přidávat funkce pomocí lua_pushcfunction()
(viz Ukázka 2.9 ř. 12) toto přidá danou funkci na zásobník, z něj je
možné ji například zavolat nebo zpřístupnit jako globální funkci (jako
libovolnou jinou proměnnou pomocí lua_setglobál()).
//přímo exportovateIná funkce
static int lua_function (lua_State *L) {
//konverze argumentů
int argl = luaL_checkinteger(L, 1);
int argN = luaL_checkinteger(L, N);
//nastavení výsledku funkce
lua_pushnumber(L, 42);
return 1;
}
//uložení jedné funkce na zásobník
lua_pushcfunction(L, lua_function);
//definice hromadného exportu funkcí
static const luaL_Reg functions[] = {
{ "foo", lua_function},
/*ukonceni null*/
{ NULL, NULL >
};
luaL_setfuncs(L, functions, 0);
Ukázka 2.9: Lua export funkce
16
2. TESTOVANÉ JAZYKY
Alternativně lze funkce přiřadit hromadně tabulce na vrcholu zásobníku
pomocí funkce luaL_setfuncs (viz Ukázka 2.9 ř. 14). V každém
případě musí být takto přidávaná funkce speciální funkce, která má
jediný C argument ukazatel na lua_State, argumenty čte ze zásobníku
a výsledky ukládá na zásobník a jako C návratovou hodnotu vrací
počet skutečně vrácených (na zásobník uložených) hodnot jako int
(viz Ukázka 2.9 ř. 2). Lua garantuje, že po zavolání zásobník obsahuje
pouze její argumenty (pro volání je vytvořen nový zásobník). Pro
konverzi argumentuje vhodné použít funkce luaL_check[typ] (), které
jsou stejné jako lua_to[typ] (), ale přeruší výpočet funkce v případě,
že hodnota není daného typu, a vrátí chybu.
K exportu libovolné C/C++ funkce je třeba, stejně jako u Pythonu,
vytvořit novou funkci, která získá ze zásobníku argumenty, vyvolá
exportovanou funkci a uloží výsledek na zásobník (viz Ukázka 2.9).
2.3.6 Volání funkcí z C++
Nejprve je třeba umístit volanou funkci na vrchol zásobníku (viz
Ukázka 2.10 ř. 1), poté přidat na zásobník argumenty funkce a poté
zavolat funkci pomocí pcallQ, jehož druhým argumentem je počet
argumentů volané funkce (ten také určuje pozici volané funkce na
zásobníku), třetím je očekávaný počet vrácených hodnot (nemusí být
shodný s počtem hodnot skutečně vraceným funkcí, Lua přebytečné
hodnoty zahodí nebo chybějící doplní hodnotami nil), třetí argument
je pozice na zásobníku s funkcí pro zpracování chyb. Po volání je volaná
funkce i s argumenty odstraněna ze zásobníku a na vrchol jsou
doplněny vrácené výsledky.
lua_getglobal(L, "foo");
//argumenty funkce
lua_pushinteger(L, argl);
lua_pushinteger(L, argN);
//zavolání funkce (očekává N argumentů a vrací jeden)
lua_pcall(L, N, 1, 0);
int result = lua_tointeger(L, -1);
Ukázka 2.10: Lua volání funkce
17
2. TESTOVANÉ JAZYKY
2.3.7 Export C komplexních typů
Komplexní struktury jsou v jazyce Lua zpravidla implementovány
pomocí Lua tabulek a metatabulek. Poměrně unikátní oproti ostatním
testovaným jazykům je, že Lua umožňuje přímo alokovat libovolně
velkou paměť zpravovanou G C jazyka Lua.
Pole Nativní pole je v jazyce Lua implementováno jako Lua tabulka
(stejně jsou implementovány např. i třídy vytvořené ve skriptu). Novou
tabulku je možné vytvořit funkcí lua_createtable(), která jako
druhý argument bere očekávanou velikost pole (počet prvků, jedná
se jen o nápovědu pro funkci, pole se automaticky zvětší, pokud je to
třeba), nastavit hodnotu v poli lze pomocí funkce lua_rawseti()(viz ř.
6 z Ukázka 2.11), nastavená hodnota musí být na vrcholu zásobníku
a je z něj funkcí lua_rawseti{) odebrána. Naopak pro získání hodnoty
z pole slouží funkce lua_rawgeti(), která uloží hodnotu z pole
na vrchol zásobníku (viz ř. 9 z Ukázka 2.11). Alternativně lze pole též
exportovat jako třídu (pro detaily viz např. [10, Array Access]).
//vytvoření nové tabulky očekávající „velikost" prvků
lua_createtable(L,velikost,0);
//umístění vkládané hodnoty na zásobník
lua_pushinteger(L,10);
//na i-tý index nově vytvořené tabulky (index -2) vloží 10
lua_rawseti(L, -2, i ) ;
//z tabulky na vrcholu získá i-tou hodnotu
lua_rawgeti(L, -1, i ) ;
value = lua_tointeger(L, -1);
Ukázka 2.11: Lua export pole
Třídy Lua umožňuje na zásobník uložit libovolnou C/C++ hodnotu
prostřednictvím hodnoty typu userdata, to je prakticky jen na Lua zásobníku
alokovaná paměť libovolné velikosti, do ní je pak množné uložit
např. kopii instance exportované třídy nebo ukazatel na originální
instanci. Ale z pohledu jazyka Lua je to pořád jen paměť na zásobníku,
pro export vlastní třídy je třeba pomocí funkce luaL_newmetatable()
18
2. TESTOVANÉ JAZYKY
vytvořit „metatabulku", která se přiřadí později vytvořeným „userdatům",
„metatabulka" jednak funguje jako definice „typu" třídy
ale hlavně umožňuje přiřadit třídě metody a atributy. Přiřazení „metatabulky"
konkrétním „userdatům" zachycuje Ukázka 2.13.
//vytvoření nové metatabulky na vrcholu zásobníku
luaL_newmetatable(L, "ClassWrapper");
//a uložení její kopie na vrchol zásobníku
lua_pushvalue(L, -1);
//nastavení atributu „ index" nové tabulky na sebe samu
lua_setfield(L, -2, "__index");
//přiřazení funkce jako metody objektu
luaL_setfuncs(L, wrapper_methods, 0);
Ukázka 2.12: Lua export třídy definice
Aby se metody mohly volat jako metody je třeba do atributu
index matatabulky přiřadit nějakou metatabulku (třeba i samu sebe)
obsahující tyto funkce. Příkladem, jak toho dosáhnout, je Ukázka 2.12,
pokud by se tabulka nepřiřadila do index, tak by se metody nedaly
volat jako metody (pomocí':'), ale pouze jako atributy typu funkce,
tedy by se automaticky nedosadila třída, na níž byla funkce volaná
jako první argument.
//alokace paměti na Lua zásobníku, jako userdata
TestClass *userdata = (TestClass *)lua_newuserdata(L,
sizeof(TestClass));
//získání dříve vytvořené metatabulky
luaL_getmetatable(L, "ClassWrapper");
//přiřazení metatabulky nově vytvořeným userdatům
lua_setmetatable(L, -2);
//do alokované paměti můžu uložit exportovanou třídu
*userdata = ...
Ukázka 2.13: Lua export třídy, vytvoření instance
Metody se exportují stejně jako funkce, jen s tím rozdílem, že jako první
parametr očekávají exportovanou třídu, to si mohou ověřit pomocí
funkce luaL_checkudata(), která zkontroluje, že userdata na zásobníku
mají přiřazenou konkrétní „metatabulku" a vrátí na ně ukazatel.
19
2. TESTOVANÉ JAZYKY
Takto lze definovat nejen běžné metody, ale i operátory, např. aritmetické
operátory (viz dokumentace [14]).
2.4 JavaScript V8
JavaScript je skriptovací jazyk hojně využívaný ve w w w stránkách.
V8 engine je implementace JavaScriptu, přesněji implementuje JavaScript(dále
jen JS) dle specifikace ECMAScript4
, vyvinutá pro prohlížeč
Google Chromé. V8 je dostupný také samostatně jako C++
knihovna s otevřeným zdrojovým kódem, kterou zde budu prezento­
vat.
2.4.1 Instalace a inicializace
Postup instalace V8 a kompilace aplikace používající V8 je komplikovanější
a je popsán na webu [8] v kapitolách „Download and build" a
„Getting Started". V této práci používám V8 engine verze 4.3, který
byl použit v prohlížeči Chromé verze 43.
Stejně tak inicializace V8 engine je oproti předchozím jazykům
komplikovanější. Nejprve je třeba inicializovat platformu, poté jednu
nebo více instancí Isolate (proměnná isolate v ukázkách), které představují
něco jako izolované virtuální stroje, a pro ně je třeba inicializovat
kontext (proměnná context v ukázkách), který definuje standardní
funkce a objekty skriptu, jenž je v něm spuštěn, při vytvoření kontextu
vznikne také globální objekt (proměnná context v ukázkách), který
lze z kontextu získat metodou Global (), a je mu možné přiřazovat globální
proměnné a funkce. Pro přesné podrobnosti odkážu na oficiální
dokumentaci ([8, Getting Started]).
Po základní inicializaci je možné začít provádět skripty. V8 neposkytuje
podporu pro načtení skriptu ze souboru, ale pouze z textového
řetězce, ten je třeba konvertovat na JS textový řetězec (viz kapitola
2.4.3), následně zkompilovat pomocí statické metody Compile() třídy
Script, která vrátí instanci této třídy, zkompilovaný skript je pak možné
provést pomocí jeho metody Run() (viz 2.14 ř. 6 a 7).
4. http://www.ecma-internátional.org/publications/standards/Ecma-262.
htm
20
2. TESTOVANÉ JAZYKY
1 HandleScope handle_scope(isolate);
2 //načteni a provedeni skriptu
3 char* c_str_script = ...
4 //konverze textového řetězce
5 Local<String> js_string_script =
v8::String::NewFromUtf8(isolate, c_str_script);
6 Local<Script> script = v8::Script::Compile(js_string_script);
7 script->Run(context);
8 int a = 2;
9 //konverze z C hodnoty int na JS hodnotu Int32
10 Local<Value> js_value = v8::Int32::New(isolate, a)
n Local<Value> js_name = v8::String::NewFromUtf8(isolate, "a")
12 //Nastaveni konvertované hodnoty jako globálni proměnná
13 global->Set(js_name, js_value);
u //opětovné ziskáni hodnoty globálni proměnné
15
js_value = global->get(js_name);
16 //konverze z JS hodnoty Int32 na C int
17 int value = js_value->Int32Value()
Ukázka 2.14: V8 jednoduchá ukázka: Handle a HandleScope, načtení
skriptu, konverze hodnot mezi JS a C++
2.4.2 Správa paměti
GC může hodnoty v paměti přesouvat, proto není bezpečné přistupovat
k nim přes klasické ukazatele. V8 používá pro přístup k hodnotám
šablony Handle < Value >, jedná se de facto o speciální ukazatele
na hodnoty spravované GC. Šablona Handle O s e používá jako typ
parametru funkce, jako instance se používají její podtřídy, nejčastější
Local < Value >, jejíž životnost je řízena instancí třídy HandleScope
tak, že při vytvoření je instance Local <> přiřazena právě aktivnímu
HandleScope a po jeho zrušení jsou všechny jím spravované instance
Local <> uvolněné (tj. G C může smazat jejich jinde neodkazované
hodnoty). HandleScope zpravidla zajišťuje, že hodnota existuje po celou
dobu běhu C/C++ funkce, kde je používána a poté je zrušena,
pokud již není potřeba. Existuje samozřejmě také možnost trvale uložených
hodnot, pro detaily o nich a správě paměti jako celku odkážu
na dokumentaci ([8, Embedder's Guide]).
21
2. TESTOVANÉ JAZYKY
2.4.3 Export jednoduchých hodnot do scriptu
Proměnné hodnoty jsou ve V8 reprezentovány jako instance potomků
třídy Value (v C/C++ se k nim přistupuje prostřednictvím Handle, viz
2.4.2), tyto třídy mají statické metody NezvQ nebo NewFrom[Typ] (),
které slouží pro konverzi z C/C++ hodnot (viz 2.14 ř. 10). Konvertovanou
hodnotu lze přiřadit objektu pomocí jeho metody Set(), prvním
argumentem je jméno funkce konvertované na JS hodnotu, druhým je
přiřazovaná hodnota.
2.4.4 Export jednoduchých hodnot ze scriptu
JS hodnoty jsou ve V8 reprezentovány jako instance potomků třídy
Value, která poskytuje množinu metod Is[Typ](), které kontrolují
zda je instance daného typu a [Typ]Value(), které vrací odpovídající
C/C++ hodnotu (viz 2.14 ř. 17). Hodnotu atributu objektu lze
získat pomocí jeho metody Get(), jejímž argumentem je jméno požadovaného
atributu konvertované na JS hodnotu.
2.4.5 Export C++ funkcí do scriptu
Opět lze přímo exportovat pouze funkce se specifickým prototypem,
zde musí mít jeden argument typu FunctionCallbacklnfo < Value >
&, který obsahuje argumenty z JS, ke kterým lze přistupovat pomocí
indexů jako k prvkům pole, a další atributy jako objekt, na němž
byla volána, a zejména atribut pro uložení návratové hodnoty, který
je dostupný pomocí metody GetReturnValueQ. Pro export obecných
C/C++ funkcí je třeba vytvořit novou funkci s daným prototypem a
exportovanou funkci z ní zavolat.
Funkce lze exportovat pomocí třídy FunctionTemplate, její statická
metoda NezvQ vytvoří z ukazatele na přímo exportovatelnou funkci
novou instanci FunctionTemplate. Z instance FunctionTemplate lze
poté získat funkční objekt a ten je již možné přiřadit jako metodu
objektu (neliší se od přiřazení atributu, viz kapitola 2.4.3). Pomocí
FunctionTemplate lze vytvořit funkční objekt pro různé kontexty, ale
v jednom kontextu by měl být pouze jeden funkční objekt získaný
z daného FunctionTemplate.
i //přímo exportovateIná funkce
22
2. TESTOVANÉ JAZYKY
void v8_function(const v8::FunctionCallbackInfo<v8::Value>&
args) {
//nastavení výsledku funkce
args.GetReturnValueO .Set(42);
}
//vytvoření šablony funkce pomocí metody New
Handle<FunctionTemplate> function_template =
v8::FunctionTemplate::New(isolate, v8_function);
//získání instance funkce
Handle<Function> func = function_template->GetFunction();
Ukázka 2.15: JS V8 export funkce
2.4.6 Volání funkcí z C++
Vyvolání JS funkce zachycuje Ukázka 2.16. Nejprve je třeba získat
funkci jako objekt (stejně jako jinou hodnotu viz kapitola 2.4.4), tu
konvertovat na hodnotu typu Function (viz Ukázka 2.16 ř.6) a poté ji
zavolat pomocí její metody Call(), parametry se předávají jako C pole
Handle.
23
2. TESTOVANÉ JAZYKY
//Konverze jména funkce na JS hodnotu
Handle<v8::Value> function_name =
v8::String::NewFromUtf8(isolate, "foo");
//získání metody objektu obj
Handle<v8::Value> value = obj->Get(function_name);
//pretypovaní JS hodnoty na JS funkci
Handle<v8::Function> func =
v8::Handle<v8::Function>::Cast(value);
//vytvoření a inicializace pole argumentů volané funkce
Handle<Value> argv[number_of_arguments] = {
};
//Vyvolání funkce
Handle<v8::Value> js_result=func->Call(context, obj,
number_of_arguments, argv);
Ukázka 2.16: JS V8 volání funkce
2.4.7 Export C komplexních typů
Obdobně jako ostatní testované jazyky i JS má své pole a třídy a V8
sice neumožňuje přímý export, ale má prostředky, jak z C++ pracovat
s JS poli a definovat nové třídy.
Pole Nejjednodušší export pole je opět zkopírování konvertovaných
hodnot do nativní reprezentace pole5
, ve V8 je to typ Array (viz 2.17),
jeho statická metoda NewQ bere jako druhý parametr dopředu alokovanou
velikost, ale velikost pole se může měnit. Prvky se do pole
vkládají pomocí metody SetQ a čtou metodou Get(). Opět lze alternativně
pole exportovat jako třídu.
5. Toto tvrzení není úplně pravdivé, testovaná verze V8 umožňuje exportovat pole
číselných hodnot i přímo prostřednictvím tzv. TypedArray, ale v textu to nezohledňuji,
protože tato možnost je pouze experimentální.
24
2. TESTOVANÉ JAZYKY
//„source" je exportované pole
int source[count];
//Vytvoření nové JS hodnoty typu pole
Handle<Array> array=v8::Array::New(isolate,count);
//hodnoty exportovaného pole se nakopírují do „array"
for (unsigned int i=0;i<count;i++) {
//Nastavení i-tého prvku pole
array->Set(i,v8::Int32::New(isolate, source [i]));
}
Ukázka 2.17: JS V8 export pole
Třídy Pro export třídyje třeba vytvořit tzv šablonu JS objektu (Object
Template), který bude exportovanou třídu reprezentovat ve skriptu.
Šablona objektu může obsahovat tzv. „skrytá pole ", což jsou ukazatele
na C/C++ data, také se jí přiřadí exportované metody (viz kapitola
2.4.5) a atributy (metodou SetAccessorQ, jako to ukazuje Ukázka 2.18).
//Vytvoření nové šablony
Local<ObjectTemplate> template = ObjectTemplate::New(isolate);
//Objekt vytvořený podle šablony bude mít jedno skryté pole
template->SetInternalFieldCount(1);
Handle<value> attribute_name = String::NewFromUtf8(isolate,
"a");
//přiřazení getteru a setteru (viz Ukázka 2.19) atributu
template->SetAccessor(attribute_name, get_a, set_a);
Ukázka 2.18: JS V8 export třídy: vytvoření šablony
Pro export atributů je třeba vytvořit getter a setter funkce (viz Ukázka
2.19). Jejich atribut PropertyCallbacklnfo < Value > & je obdobou
FunctionCallbacklnfo < Value > & popsaného v kapitole 2.4.5, ale
neobsahuje argumenty. Tento atribut obsahuje zejména instanci exportované
třídy, k níž getter či setter přistupuje. Ještě zde zmíním metodu
SetlndexedPropertyHandier () třídy ObjectTemplate, jež umožňuje nastavit
funkce kontrolující indexovaný přístup k objektu, jejími argumenty
jsou funkce obdobné getteru a settru (viz níže), ale jako první
argument mají celočíselný index místo jména atributu.
25
2. TESTOVANÉ JAZYKY
1 //příklad Getteru
2 void get_a(Local<String> property, const
PropertyCallbacklnfo<Value>& info) {
3 //získání „this" JS objektu
Handle<Object> this = info.Holder();
5 //získání dříve uloženého ukazatele na instanci C++ třídy
6 Local<External> wrap =
Local<External>::Cast(this->GetInternalField(0));
7 TestClass* instance =
static_cast<TestClass*>(wrap->Value());
8 Handle<Value> return_value = ...;
9 //vrácení hodnoty
10 inf o .GetReturnValueO . Set (return_value);
n }
12 //Setter je obdobný ale navíc má parametr „value" obsahující
novou hodnotu atributu
13 void set_a(Local<String> property, Local<Value> value, const
PropertyCallbacklnfo<void>& info) {
14 . . .
15 >
Ukázka 2.19: JS V8 export třídy: export atributu
Nakonec je třeba ze šablony vytvořit novou instanci a do jejího
skrytého pole uložit metodou SetInternalField() ukazatel na exportovanou
instanci, ukazatel konvertovaný na hodnotu typu External,
toto zachycuje Ukázka 2.20. Uložený kazatel lze z objektu opět získat
pomocí metody GetInternalField() (viz Ukázka 2.19 ř. 6). Ještě
poznamenám, že V8 neposkytuje (anebo jsem jej nenalezl) úplně spolehlivý
způsob, jak se ujistit, že poskytnutý objekt je skutečně výše
vytvořenou instancí.
26
2. TESTOVANÉ JAZYKY
1 //Vytvoření instance JS objektu z dříve vytvořené šablony
2 Local<Object> obj = objectTemplate->NewInstance();
3 TestClass ptr = ...
4 //Uložení ukazatele na exportovanou instanci do objektu
5 obj->SetInternalField(0, External::New(isolate, ptr));
Ukázka 2.20: JS V8 export třídy: zabalení exportované třídy
2.5 JavaScript SpiderMonkey
SpiderMonkey engine je implementace JavaScriptu vyvinutá pro prohlížeč
Mozilla Firefox, stejně jako V8 i SpiderMonkey implementuje
JavaScript dle specifikace ECMAScript a je dostupný samostatně jako
C++ knihovna s otevřeným zdrojovým kódem.
2.5.1 Instalace a inicializace
Obdobně jako V8 i SpiderMonkey má poměrně rozsáhlou a komplikovanou
instalaci i inicializaci, pro detaily opět odkážu na dokumentaci
([4] kapitoly „Build Documentation" a „JSAPI User Guide"). V této
práci používám SpiderMonkey verze 38, kterou používá prohlížeč
Firefox stejné verze. Co se inicializace týče, z pohledu další práce
je důležité zejména vytvořit a inicializovat nový kontext (JSContext,
proměnná context v ukázkách) a globální objekt (proměnná globál
v ukázkách). Alespoň jedna z těchto dvou proměnných totiž vystupuje
jako argument většiny funkcí jeho C/C++ rozhraní (pro detaily opět
odkážu na dokumentaci[4]).
Poté je možné začít pracovat se skripty. Pro provedení skriptu je
třeba jej nejprve zkompilovat buď ze souboru, nebo z textového řetězce
pomocí funkce Compile() (pro detaily opět odkážu na [4]). Tato
funkce vrací zkompilovaný skript pomocí výstupního argumentu,
proto je třeba nejprve vytvořit proměnnou pro uložení zkompilovaného
skriptu (RootedScript) a také kompilační volby (CotnpileOptions).
Zkompilovaný skript je možné vykonat funkcí }S_ExecuteScript() (viz
Ukázka 2.21 ř. 3 až 3).
27
2. TESTOVANÉ JAZYKY
JSAutoCompartment ac(context, global);
//kompilace a vykonáni skriptu
JS::RootedScript s(context);
//volby pro kompilaci skriptu
JS::CompileOptions co(context);
JS::Compile(context, global, co, "soubor_skriptu.js",
fescript);
JS_ExecuteScript(context, global, script);
//hodnota ke konverzi
int a = .. . ;
//konverze z C int na JS hodnoty Int32
Value js_value = Int32Value(a);
//„Rootování" konvertované hodnoty
Rooted<Value> rooted_value (context, js_value);
//konverze z JS hodnoty Int32 zpět na C int
a = rooted_value->toInt32();
Ukázka 2.21: SpiderMonkey jednoduchá ukázka: Načtení skriptu,
konverze hodnot a „rootování" JS hodnot
2.5.2 Správa paměti
SpiderMonkey podobně jako V8 používá k odkazování hodnot spravovaných
GC třídy Handle < > (jedná se o jinou třídu než u V8), které
opět vystupují jako ukazatele. Nejčastější případy takových hodnot
jsou Value, což je obecná JS hodnota, a JSObject*6
, což je ukazatel na
JS objekt. Podtypů Handle O existuje několik druhů, pro detaily
o nich a jejich použití odkážu na [4, G C Rooting Guide]. Oproti V8
jsou ve SpiderMonkey JS hodnoty z C/C++ funkcí vraceny jako běžné
ukazatele, ale pro jejich uložení by vždy mělo být použito Handle < >.
Zde opět zmíním jen nejčastější typ Rooted <>, ten slouží k odkazování
hodnoty ze zásobníku (chová se obdobně jako Local O ve V8)
a životnost jím držené hodnoty spravuje JSCompartment7
(obdobou
HandleScope z V8, je zde JSAutoCompartment, viz Ukázka 2.21).
6. I JSObject* je možné konvertovat na Value.
7. Správa pomocí JSCompartment zde není fakticky nezbytná, ale slouží k urychlení
GC, viz [4].
28
2. TESTOVANÉ JAZYKY
Ještě zmíním MutableHandle <>, který se využívá pro výstupní
argumenty funkcí a lze získat z Rooted < > pomocí operátoru &. Nakonec
uvedu, že SpiderMonkey nabízí typedefy šablony Handle O
podle typu hodnoty, např. Rooted < Value > je ekvivalentní Rooted
Value, obdobně MutableHandle < Value > je zcela ekvivalentní
MutableHandle Value (úplný seznam opět viz [4, GC Rooting Guide])
2.5.3 Export jednoduchých hodnot do scriptu
Jak již bylo řečeno, JS hodnoty jsou reprezentovány pomocí třídy Value.
SpiderMonkey C/C++ rozhraní poskytuje funkce [Typ]Value() pro
konverzi z C/C++ hodnot na JS hodnoty (viz Ukázka 2.21 ř. 11). Pro
nastavení konvertované hodnoty jako atribut objektu slouží funkce
JS_SetProperty() . Zde je třeba ještě zmínit, že konverze textového řetězce
je o něco složitější, nejprve třeba konvertovat řetězec na JSString
např. pomocí metody }S_NewStringCopyZ() (viz dokumentace[4]) a
ten již lze konvertovat na Value pomocí StringValue().
2.5A Export jednoduchých hodnot ze scriptu
Třída Value obdobně jako ve V8 poskytuje metody pro zkontrolování
aktuálního typu (metody is[Typ]()) a konverzi na typ (metody
to[Typ](), viz Ukázka 2.21 ř. 15). Pro získání hodnoty atributu objektu
slouží funkce }S_GetProperty(). Opět jsou výjimkou textové řetězce,
kde hodnotou získanou z metody toStringQ je jeho interní JS reprezentace,
tu je třeba ještě konvertovat pomocí funkce }S_EncodeString
ToBuffer()(viz dokumantace [4]).
2.5.5 Export C++ funkcí do scriptu
Opět lze přímo exportovat pouze specifické funkce (viz Ukázka 2.22 ř.
2) a pro export obecných je třeba vytvořit novou funkci. Argumenty
jsou do exportované funkce předány pomocí C/C++ pole hodnot
Value, ale je třeba k nim přistupovat pomocí struktury CallArgs získané
z funkce CallArgsFromVp(), které se předá toto pole a jeho délka
(jak je vidět na ukázce), protože pole obsahuje i objekt, na němž byla
funkce volána, a místo pro uložení návratové hodnoty. Argumenty
jsou pak z CallArgs dostupné pomocí indexů (obdobně jako u V8).
29
2. TESTOVANÉ JAZYKY
Funkce se přiřadí objektu pomocí funkce }S_DefineFunction()(viz
2.22 ř. 14)(pro detaily viz dokumentace [4])
//Přímo exportovatelná JS funkce
bool spidermonkey_function(JSContext *context, unsigned argc,
JS::Value *vp){
//Získání argumentů
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
//Získání objektu na němž byla funkce volána, t j . hodnoty
„this" v JS scriptu
Handle<Value> this = args.thisvO;
//nastavení výsledku funkce
args.rval().setlnt32(42);
//vrací true při úspěchu a falše jinak
return true;
}
RootedObject obj = ...
//Přiřazení funkce objektu „obj"
JS_DefineFunction(context, obj, "foo",
&spidermonkey_function, number_of_arguments, 0)
Ukázka 2.22: JS SpiderMonkey export funkce
2.5.6 Volání funkcí z C++
K vyvolání je třeba získat funkci jako objekt (viz kapitola 2.5.4), vytvořit
pole argumentů, k tomu lze použít třídu AutoValueVector nebo
AutoValueArray, instanci RootedValue pro uložení návratové hodnoty
a nakonec zavolat funkci CallQ, viz Ukázka 2.22.
//příprava pole argumentů
JS::AutoValueVector args(context);
//přidání prvního argumentu
args.append(JS::Int32Value(1));
//Proměnná pro uložení návratové hodnoty
RootedValue rval(context);
//zavolání funkce „func" na objektu „object"
JS::Call(context,object,func,args,&rval);
Ukázka 2.23: JS SpiderMonkey export funkce
30
2. TESTOVANÉ JAZYKY
2.5.7 Export C komplexních typů
Jak již bylo vidět v předchozích kapitolách, oproti V8, používajícímu
značně objektově orientované rozhraní, SpiderMonkey používá spíše
procedurální přístup, což se o to více projevuje v exportu složitých
typů.
Pole Opět je nejjednodušší vytvořit objekt reprezentující pole, k tomu
slouží funkce }S_NewArrayObject()/ a do něj pak jednotlivé hodnoty
postupně nakopírovat. Prvky lze do pole přiřazovat funkcí }S_Set
Element () (číselné hodnoty není třeba dopředu konvertovat) a číst je
funkcí JS_GetElement() (viz Ukázka 2.24).
//„source" je exportované pole
int source[count];
//Vytvoření nového pole s předalokovanou velikostí
JS::Rooted<JSObject*> arr(context, JS_NewArrayObject(context,
length));
for (unsigned int i=0;i<count;i++) {
//Nastavení i-tého prvku pole
JS_SetElement(context, arr, i , source [i]));
RootedValue val(context);
//Uložení i-tého prvku pole do proměnné „val"
JS_GetElement(context, arr, i , &val));
Ukázka 2.24: JS SpiderMonkey export pole
K inicializaci nového pole lze také využít instanci třídy AutoValue
Vector (použita v kapitole 2.5.6 pro předání argumentů funkci) nebo
AutoValueArray s konvertovanými hodnotami, kterými se nové pole
naplní. A samozřejmě i zde platí, že alternativně lze pole exportovat
jako třídu.
Třídy SpiderMonkey poskytuje více možností, jak vytvořit novou
třídu, postup z Ukázky 2.25 m i připadá nejjednodušší. Nejprve se
vytvoří statická definice, které se nastaví pouze jméno a bitová maska
vlastností, která se nastaví na hodnotu }SCLASS_HAS_PRIVATE,
ta zajistí, že její instance alokuje místo pro ukazatel na C/C++ data.
Z definice se funkcí JS_NewObject() vytvoří nový objekt, do nějž
se pomocí funkce }S_SetPrivate() uloží ukazatel na exportovanou
31
2. TESTOVANÉ JAZYKY
třídu a přiřadí metody a atributy. Uložený ukazatel je pak možné
z výše vytvořeného JS objektu získat pomocí funkce }S_GetPrivate()
nebo }S_GetInstancePrivate(), druhá možnost je preferovaná, protože
umožňuje zkontrolovat, že JS objekt je instance zde vytvořené třídy
(viz dokumentace [4]).
1 //Struktura s definicí nové třídy
2 JSClass class_wrapper = {
3 "TestClass",
JSCLASS_HAS_PRIVATE,
5 > ;
6
7 //Vytvoření nového instance JS třídy
s JSObject* obj = JS_NewObject(context, &class_wrapper);
9 RootedObject robj(context, obj);
10
11 TestClass* ptr = ...
12 //Uložení ukazatele do nově vytvořené instance
13 JS_SetPrivate (obj , ptr);
14
15 //přiřazení getteru a setteru objektu „obj" pro atribut a
16 JS_DefineProperty(context, robj, "a", UndefinedHandleValue,
JSPR0P_SHARED, get_a, set_a);
Ukázka 2.25: JS SpiderMonkey export třídy
Obdobně jako ve V8 lze C/C++ atributy exportovat pomocí getter a
setter funkcí, ve SpiderMonkey k tomu lze použít funkci }S_Define
Property(), která objektu definuje nový atribut (viz 2.25 ř. 16, pro detaily
odkážu na dokumentaci[4]). Pro export C/C++ proměnné je
třeba nový atribut definovat s vlastností }SPROP_SHARED, která
zajistí, že se pro hodnotu nebude alokovat nová paměť, ale vždy se
nová hodnota získá a uloží pomocí getter a setter funkcí, ty jsou ve
SpiderMonkey, obdobně jako v Lua, a v kontrastu k V8, běžné přímo
exportovatelné funkce (viz kapitola 2.5.5). Ještě poznamenám, že ve
statické definici třídy lze definovat i další položky, např. funkce kontrolující
přístup ke všem atributům objektu (viz [4, JSClass]), čehož lze
využít např. při exportu třídy reprezentující pole.
32
2. TESTOVANÉ JAZYKY
2.6 Správa paměti obecně
Zde se vrátím k druhému problému spojenému s exportem dat do
skriptovacího jazyka, a tím je správa paměti. Tento problém se projeví
v okamžiku, kdy je třeba ve skriptu pracovat s ukazateli a dynamicky
alokovanou pamětí. Jedním řešením je vyhnout se mu, nepoužívat
ukazatele a exportovat všechna data jako kopie, jež už si pak může
GC zpravovat podle sebe. To je relativně jednoduché a u jednoduchých
hodnot často používané řešení, jeho nevýhodou je samozřejmě
paměťová i časová náročnost. U složitých struktur, jako jsou C/C++
struktury a třídy, však ani to nemusí být vždy zcela triviální. Například
chceme-li exportovat klasický spojovaný seznam a funkci, která
zpracovává nějakou jeho část a jako argumenty očekává ukazatele na
první a poslední zpracovávaný prvek. Pak je přinejmenším potřeba
zajistit, že předané ukazatele ukazují do stejné kopie seznamu.
Pokud nechceme nebo není možné data kopírovat a je třeba použít
ukazatele, je nutné rozhodnout, zda paměť bude spravovat programátor,
nebo GC. V případě, že správu paměti přenecháme GC, je nezbytné
zajistit, že veškeré objekty, jejichž paměť je odkazovaná z C/C++ kódu,
stále existují i v G C . V tom případě by ale C kód musel udržovat
informaci o tom, kterému objektu paměť patří, aby poté, co s ní přestane
pracovat, mohl informovat GC, že daný objekt již není potřeba.
Ještě složitějším se problém stane v momentě, kdy je třeba exportovat
nějakou strukturu nejen jako celek, ale i jednotlivé její části. Uvažme
například situaci z Ukázky 2.26, kde ExpArray je třída exportující
pole a destroy(arr) říká, že pole arr již není ve skriptu potřeba, ovšem
v momentě volání destroy(arr) proměnná x stále ukazuje na prvek
z arr. Pak ale G C musí vědět, že pole není možné uvolnit, a naopak je
třeba, aby jej poslední používaný prvek při svém zrušení informoval,
že je možné uvolnit paměť celého pole.
1 arr = ExpArray(...);
2 . . .
3 x = arr [2] ;
4 destroy(arr);
Ukázka 2.26: Problém exportu pole
33
2. TESTOVANÉ JAZYKY
C Zdroj Script Proxi Uzvatelska Trida
Programátor
Zdroj není používán,
tak uvolní paměť
Garbage
Co lector
closeO closeO
<i ±J<
proxi volá
isClosed{) na
dealokované paměti
volá destruktor
'i Script Proxi GC volá destruktor
Obrázek 2.1: Problém programátorem spravované paměti.
Pokud naopak zprávu necháme na programátorovi, tak to na něj
hlavně klade nároky, na které není v cílovém jazyce zvyklý, ale také to
vytváří velký prostor pro špatně odhalitelné chyby. Například si představme
situaci z Obr. 2.1, kde exportujeme třídu reprezentující nějaký
zdroj (např. síťový soket, na obrázku jako C Zdroj) pomocí zástupné
třídy implementované v cílovém jazyce (na obrázku jako Script Proxi),
která zdroji jen přeposílá volání z cílového jazyka a naopak, a pak
máme uživatelskou třídu, která zástupnou třídu používá. V momentě,
kdy se programátor rozhodne paměť uvolnit, už není žádná ze tříd
používaná, ale problém na obrázku spočívá v tom, že programátor,
jenž vytvořil zástupnou třídu, se rozhodl zkontrolovat v destruktoru,
zda byl držený zdroj uvolněn, protože ale G C obecně negarantuje,
kdy se destruktor provede, tak k provedení destruktoru může dojít
až poté, co je paměť C/C++ třídy reprezentující zdroj již uvolněna a
přístup k ní je v ten moment přístupem do již nealokované paměti.
2.7 Podpůrné nástroje
Pro většinu testovaných jazyků existují knihovny a aplikace, jež se
snaží automatizovat, nebo alespoň zjednodušit tvorbu provázání mezi
C/C++ kódem a skriptovacím jazykem. Jednotlivé nástroje se výrazně
liší jak co do způsobu práce s nimi, tak i poskytovanou funkcionalitou.
34
2. TESTOVANÉ JAZYKY
Některé jen přidávají nové funkce, jiné poskytují kompletně nové
rozhraní. V této kapitole uvedu příklady několika z nich.
V zásadě se tyto nástroje dají rozdělit do dvou skupin. Jednou jsou
samostatné aplikace, které vygenerují, zpravidla C/C++, zdrojové
soubory. Druhou jsou knihovny, jež je možné používat místo nebo
ve spojení s C/C++ rozhraním cílového jazyka. Existují přinejmenším
dva problémy, které se ve větší či menší míře vyskytují u všech
podobných nástrojů. První problém je výkonový. Tyto nástroje se
snaží poskytovat jednoduché rozhraní pro řešení komplexního problému,
k tomu musí používat co nejobecněji použitelná řešení, ta jsou
však často v konkrétních situacích neoptimální. Z obecnosti použitých
řešení také plyne, že jsou zpravidla komplikovaná (ošetřují mnoho
speciálních případů), a pokud dojde k chybě (například nevhodným
použitím daného nástroje), může být komplikované vysledovat její
příčinu.
Pro jazyky Python a Lua existuje mnoho různých volně dostupných
podpůrných nástrojů. V případě JavaScriptu je kvůli rychlému vývojovému
cyklu zvolených implementací podpůrných nástrojů méně a
většina déle vyvíjených jich již zanikla. Pro ChaiScript nemá smysl podpůrné
nástroje uvažovat, protože tuto funkci plní přímo jeho C/C++
rozhraní.
2.7.1 SWIG
SWIG[5] umožňuje automaticky vygenerovat kód exportující zadané
C/C++ funkce a struktury do různých cílových jazyků. Z výše testovaných
patří mezi podporované jazyky Python, Lua a JavaScript (ve verzi
3.0.6, kterou jsem zkoušel, je podporován V8 engine, SpiderMonkey
nikoliv).
Vstupem pro SWIG jsou tzv. „interface" soubory. Obsahem těchto
souborů jsou běžné C/C++ deklarace funkcí, typů a proměnných (až
na výjimky, viz dokumentace [5]) doplněné o speciální direktivy začínající
znakem '%'. V jednoduchém případě stačí použít deklarace
z hlavičkových souborů exportovaného kódu. Pro složitější případy
poskytuje SWIG jednak standardní interface soubory (např. export
polí, ukazatelů nebo standardních C++ kontejnerů), které je možné
importovat do vlastního interface souboru, a pak mnoho direktiv
ovlivňujících, jak se co má exportovat, zejména tzv. „typeMaps", které
35
2. TESTOVANÉ JAZYKY
umožňují předefinovat, jak se bude exportovat konkrétní typ v konkrétní
situaci (když je například atributem funkce), přitom se hledí na
typedef typu konkrétní proměnné.
SWIG se spouští jako konzolová aplikace, která z interface souboru
vygeneruje typicky C/C++ zdrojový soubor modulu cílového
jazyka. Výsledný C/C++ zdrojový soubor je třeba zkompilovat na
modul cílového jazyka, zde postup závisí na konkrétním jazyku. V závislosti
na jazyku mohou být výsledkem zpracování i další soubory,
např. pro Python vygeneruje ještě skript. Vždy je dobré před použitím
konkrétního jazyka konzultovat příslušnou kapitolu [5].
SWIG bohužel není určen pro podporu integrace skriptovacího jazyka
do C/C++ aplikace, ale naopak pro export C/C++ funkcionality
do skriptovacího jazyka. Proto např. pro volání funkcí skriptovacího
jazyka je třeba využít C /C++ rozhraní daného jazyka. Vygenerované
typy reprezentující exportované třídy nejsou navíc z C/C++ běžně dostupné.
Je však možné pomocí přepínače —external — runtime vygenerovat
hlavičkový soubor zpřístupňující rozhraní, jež s nimi umožňuje
pracovat, zejména umožňuje z C/C++ zabalit nebo vybalit instanci
exportované C/C++ struktury. Ale toto rozhraní není příliš uživatelsky
přívětivé a bezproblémové. Když jsem SWIG zkoušel, musel jsem
zpravidla zasahovat do vygenerovaného kódu, aby rozhraní fungovalo,
ale to mohlo být způsobeno mou neznalostí či nepochopením
tohoto rozhraní.
2.7.2 BOOST.PYTHON
BOOST.Python[2] je velmi komplexní knihovna poskytující vlastní
C++ rozhraní pro práci s Pythonem. Toto rozhraní je postavené nad
standardním C rozhraním Pythonu a je možné zároveň využívat možností
obou. Python je třeba inicializovat pomocí funkce jeho C rozhraní
Py_Initialize() (viz kapitola 2.2.1). Jednou z nevýhod této knihovny
je, že nepodporuje Py_Finalize() a korektním ukončením práce s Pythonem
je v případě jejího využití až ukončení celé aplikace.
BOOSTPython definuje makra, třídy a šablony značně zkracující a
zjednodušující export C++ třídy, příklad je na Ukázce 2.27. Pro export
standardních C++ kontejnerů lze využít předpřipravené tzv. indexing_
suite (viz [2]).
36
2. TESTOVANÉ JAZYKY
1 using namespace boost::python;
2 //vytvořeni nového modulu s exportem třídy
3 BOOST_PYTHON_MODULE(mymodule)
4 {//Export třídy
s class_<TestClass, TestClass*>("TestClass")
6 //export konstruktoru
7 .def(init<int, int,int,int>())
8 //export metody třídy
.def("method", &TestClass::method)
io //export atributu třídy
.def_readwrite("a", &TestClass::a)
i3 > ;
Ukázka 2.27: BOOST.Python: ukázka exportu třídy
Knihovna také poskytuje komplexní možnosti, jak řídit správu
paměti exportovaných typů (viz kapitola 2.6) a mnoho dalších aspektů
propojení C/C++ kódu s jazykem Python. Celkově je knihovna velmi
rozsáhlá, což ji činí poměrně náročnou na naučení.
2.7.3 LuaWrapper
LuaWrapper[12] je malá knihovna, která obaluje C rozhraní jazyka
Lua a poskytuje k němu vlastní objektově orientované C++ rozhraní ne
nepodobné např. rozhraní ChaiScriptu. Knihovna je zajímavá zejména
proto, že abstrahuje od Lua zásobníku. Použití této knihovny je na
Ukázce 2.28.
37
2. TESTOVANÉ JAZYKY
//inicializace
LuaContext lua;
//export atributu třídy
lua.registerMember("a", feTestClass::a);
//export metody třídy
lua.registerFunction("method", feTestClass::method);
//vytvoření nové proměnné v Lua
lua.writeVariable("a", 42);
//stejně lze exportovat funkci nebo instanci dříve exportované
třídy
TestClass instance(2,3,4,5);
lua.writeVariable("inst", feinstance);
//vykonání Lua kódu
lua.executeCode("inst.a = 10;");
Ukázka 2.28: LuaWrapper: ukázka použití
2.7.4 Cython
Cython[l] je rozšíření jazyka Python, které jednak umožňuje ze skriptu
v Pythonu vygenerovat ekvivalentní C/C++ zdrojový kód využívající
C rozhraní Pythonu. Výsledný C/C++ kód lze zkompilovat do sdílené
knihovny, již lze z jazyka Python importovat jako modul. Validní Python
kód je také validní Cython kód, proto zde uvedu pouze některá
specifika Cythonu, pro kompletní informace odkážu na dokumentaci
[1].
Cython ale hlavně umožňuje přímo pracovat s C/C++ datovými
strukturami a funkcemi. C/C++ proměnné a funkce se definují stejně
jako proměnné a funkce Pythonu a stejně se s nimi i pracuje. Ze se
jedná o C/C++ proměnnou či funkci, označuje klíčové slovo cdef
před její definicí, u proměnných za ním navíc musí následovat C/C++
datový typ.
C/C++ typy a funkce je možné importovat z hlavičkových souborů,
každý importovaný prvek (funkci, proměnnou, typ) je však nutné
explicitně uvést a je třeba mít na paměti, že se jedná o C/C++ datové
typy, nikoliv typy Pythonu, není tedy například možné předat takto
exportovanou funkci, nebo instanci takto exportovaného typu jako
argument Python funkce. Výjimkou jsou jednoduché C typy a některé
38
2. TESTOVANÉ JAZYKY
standardní C++ třídy, které Cython dokáže implicitně konvertovat.
Cython umožňuje definovat C/C++ funkce a vygenerovat hlavičkový
soubor s jejich deklarací, takto je možné jednoduše vytvořit C/C++
rozhraní pro volání funkcí Pythonu. Obdobně je možné využít Cython
k definování Python třídy, která interně pracuje s C/C++ třídou, a
využít jej tak k exportu C/C++ typů do Pythonu. Výhodou Cythonu
v těchto případech je, že definice takovéto funkce či třídy je stejně
snadná jako definice běžné funkce či třídy jazyka Python (viz např.
[1, Using C++ in Cython]). Při použití v projektech, které míchají C
a C++, může být nevýhodou Cythonu, že v tomto případě nelze tak
snadno importovat čistě-C funkce (tj. ty, jejichž hlavičkové soubory
jsou includované v extern "C" bloku), viz [1, Using C++ in Cython].
39
3 Měření výkonu
Pro porovnání výkonnosti a schopností jednotlivých jazyků jsem vytvořil
sadu testů. Pro potřeby testování používám Google Benchmark
framework[9], který opakovaně prochází měřený úsek kódu a měří čas
na jeho průchod, dokud nezíská jistotu stabilního výsledku. Přestože
se v průběhu měření úsek měří opakovaně, je jedno měření poměrně
krátké, a ačkoliv jako výsledky používám procesorový čas, případné
krátkodobé zpomalení systému by mohlo ovlivnit všechny (či výraznou
část) průchody jen některých jazyků a způsobit nekonzistentní
výsledky. Rozhodl jsem se proto vyloučit vliv případného krátkodobého
zpomalení systému tak, že spouštím celou sadu lOOkrát a
výsledky z jednotlivých měření průměruji. Existuje mnoho oblastí,
v nichž je možné jednotlivé jazyky porovnat (například jednotlivé
aritmetické operace, práce se seznamy, dlouhé či krátké funkce atd.)
a za různých podmínek (např. při velkém či malém počtu objektů
v paměti), a proto nelze vytvořit obecně platné srovnání jazyků, ale
je nutné jazyky porovnávat přímo pro potřeby konkrétního projektu.
Z diskuze s vývojáři plánovače vyplynulo, že očekávaným použitím
jazyka je export poměrně krátkých a jednoduchých funkcí. V této práci
se proto zaměřuji na export dat a funkcí do skriptovacího jazyka a volání
krátkých, ve skriptu definovaných funkcí. Testy byly spouštěny na
stroji s procesorem Intel Core 2 Duo 2,5 M H z , 4GB R A M a operačním
systémem Ubuntu 14.04.
3.1 Vyvolání exportované funkce
S vyvoláním funkce exportované z C/C++ je spojena jistá režie, cílem
prvního testu je porovnat tuto režii v jednotlivých jazycích. Test, který
jsem pro to vytvořil, volá pomocí C/C++ rozhraní cílového jazyka
exportovanou funkci. Měřil jsem čas od vyvolání po návrat z funkce
(viz Ukázka 3.1).
Výsledky měření zachycuje graf na obr. 3.1. Dobu na volání funkce
jsem měřil pro každý jazyk ve třech případech. V prvním případě byla
funkce exportována přímo tak, jak je na ukázce (žluté sloupce). Ve
druhém byla tatáž funkce definovaná jako metoda objektu bez argumentů,
pro niž hodnoty a, b, c, d jsou hodnoty atributů C++ třídy a tak
41
3- MĚŘENÍ VÝKONU
1000
900
800
700
600
500
400
300
200
100
0
Porovnání výkonové náročnosti exporu funkce
l i l
l funkce jako metoda
i metoda třídy
funkce
SpiderMonkey JSV8 JS Python LUA ChaiScript
Obrázek 3.1: Porovnání doby volání exportované funkce.
nedochází k předávání argumentů a konverzi na C hodnoty (červené
sloupce v grafu). Cílem tohoto měření je porovnat náročnost kontroly
a konverze argumentů u jednotlivých jazyků. Ve třetím byla stejná
funkce jako v prvním případě, pouze definovaná jako metoda třídy
(modré sloupce). Cílem tohoto měření je zjistit případnou dodatečnou
režii spojenou s vyvoláním funkce na objektu oproti volání globální
funkce.
1 int func(int a, int b, int c, int d) {
2 return a * b - c + d;
3 >
Ukázka 3.1: Exportovaná funkce
Celkem jednoznačným vítězem tohoto testu je SpiderMonkey engine,
pouze v případě volání metody bez argumentů je rychlejší Python.
Velký rozdíl ve výkonu Pythonu je pravděpodobně způsoben
konverzí argumentů. Lua vykazuje výraznou dodatečnou režii při
volání funkcí exportovaných jako metody, tato režie je způsobena kontrolou
typu „userdat"(viz kapitola 2.3.5). Hodnoty ChaiScriptu jsou
ořezané kvůli omezení osy Y na 1000 ns, bez tohoto omezení by v
grafu zanikly rozdíly mezi jednotlivými jazyky, protože ChaiScript je
42
3- MĚŘENÍ VÝKONU
asi o dva řády pomalejší než ostatní jazyky . Toto je obecná situace a
bude se vyskytovat i u ostatních testů.
3.2 Rychlost paměťového přenosu
Tento test porovnává režii spojenou s konverzí rozsáhlého pole hodnot
z C do cílového jazyka a přístupem ke konvertovaným hodnotám
z cílového jazyka. V testu používám jednoduchou konverzi pole popsanou
u jednotlivých jazyků, v případě SpiderMonkey je použita
verze naplnění pole pomocí třídy AutoValueVector, která se ukázala
být rychlejší. Test nejprve zkonvertuje C pole 1000 hodnoty typu int
a poté zavolá ve skriptu definovanou funkci, která jako argumenty
dostane exportované pole společně s jeho velikostí, a každý jeho prvek
přečte, zvětší o 1 a poté opět zapíše (viz verze pro jazyk Python
na Ukázce 3.2). Výsledky měření zachycuje graf na obr. 3.2. Modré
sloupce představují celý výše popsaný test, červené jen samotnou
konverzi pole bez zavolání testovací funkce.
1 def testMem(array, memSize):
2 for i in range(0,memSize):
3 array[i]=array[i]+l;
Ukázka 3.2: Python verze funkce pro otestování datového přenosu
V celkovém testu je, jak už jsem předznamenal, opět nejpomalejší
ChaiScript2
, druhým nejpomalejším je V8, který je asi třikrát pomalejší
než nejrychlejší Lua.
Z grafu je vidět, že u většiny jazyků je konverze pole poměrně
rychlá, ale většinu času tvoří jeho modifikace ve skriptu, výjimkou
je V8, u něhož je většina času tvořena konverzí pole, ale naopak je
velmi rychlé při jeho zpracování (prakticky srovnatelné s průchodem
stejně velkého C/C++ pole). Zdá se, že V8 je silně optimalizovaný na
rychlost manipulace s objekty na úkor rychlosti jejich alokace3
. Toto
1. Pro úplnost uvedu, že vyvolání funkce jako metody trvalo 3730,8 ns, metody
2086,95 ns a funkce 3604,35 ns.
2. Čas celkového testu je 4 274 240,33 ns, konverze je u ChaiScriptu pouze zkopírování
vektoru v C/C++, takže nemá smysl se jí zabývat
3. Napadlo mě, že pomalá konverze by mohla být mojí chybou, ale vytvoření stejně
velkého pole ve skriptu trvá obdobně dlouho.
43
3- MĚŘENÍ VÝKONU
Overhead paměťového přenosu
Konverze pole 1000 hodnot int, jejich přečtení a modifikace ve skriptu
500000
450000
„ 400000
> 350000
OJ
| 300000
.- 250000
| 200000
g 150000
3 100000
o
50000
0
SpiderMonkey JS V8 JS Python LUA ChaiScript
Obrázek 3.2: Porovnání doby konverze a průchodu exportovaného
pole.
ukazuje, že V8 není úplně vhodné pro export velkých polí, z nichž se
ve skriptu zpracovávají pouze malé části, ale naopak bude excelentní
volbou, pokud je třeba s exportovaným polem rozsáhle manipulovat.
U SpiderMonkey je to naopak, konverze pole je nejrychlejší, zato jeho
zpracování skriptem je pomalé.
Jak uvádím u většiny jazyků (kromě ChaiScriptu), alternativně
je možné exportovat C/C++ pole jako novou třídu cílového jazyka,
tento způsob exportu zde neporovnávám, protože by byl závislý na
implementaci takovýchto tříd.
3.3 Rychlost funkce definované ve skriptu
Cílem tohoto testu je porovnat rychlost jednotlivých jazyků při provádění
krátkých funkcí definovaných ve skriptu, ale díky tomu, že
testovaná funkce je velmi krátká a jednoduchá, lze tento test zároveň
považovat za srovnání rychlosti vyvolání funkce definované skriptem
cílového jazyka. Testovaná funkce je vždy obdoba funkce z kapitoly
3.1, ale definovaná ve skriptu testovaného jazyka (Ukázka 3.3 zobrazuje
její verzi pro Python). Výsledky měření zachycuje graf na obr.
3.3.
44
3- MĚŘENÍ VÝKONU
Porovnání rychlosti vykonání funkce definované ve skriptu
SpiderMonkey JS V8 JS Python LUA ChaiScript
Obrázek 3.3: Porovnání doby volání funkce definované ve skriptu.
1 def testFunc(a,b,c,d):
2 e=a*b-c+d;
3 return e;
Ukázka 3.3: Python verze funkce pro test rychlosti skriptu
I v tomto testu je nejpomalejší ChaiScript4
, druhým nejpomalejším je
SpiderMonkey, který je zde přibližně 3krát pomalejší, než je v tomto
testu nejrychlejší V8. Zajímavé může být porovnání výkonu při volání
exportované funkce, kde je většina jazyků rychlejší než v tomto testu.
Výjimkou je opět V8, které je naopak o něco rychlejší zde. To spolu
s pozorováním z předchozího testu ukazuje na výraznou optimalizaci
při kompilaci skriptu.
4. Zde 16142,66 ns.
45
4 Osobní zkušenosti a celkové vyhodnocení
Zde bych chtěl uvést své subjektivní poznatky z pohledu uživatele
C/C++ rozhraní jednotlivých jazyků a celkové zhodnocení testovaných
jazyků. O d skriptovacího jazyka pro plánovač je požadováno
zejména jednoduché rozhraní, jak již bylo uvedeno v úvodu kapitoly 3,
proto je to hlavním kritériem mého hodnocení. Plánovač interně často
používá C struktury a pole, proto v hodnocení rozhraní jazyka silně zohledňuji
export komplexních typů. Posledním kritériem je pak výkon
jazyka v testech.
4.1 ChaiScript
Jednoznačnou výhodou ChaiScriptu je bezkonkurenční jednoduchost
jeho integrace do C/C++ aplikace a práce s ním, většinu problémů
spojených s přechodem mezi různými jazyky před uživatelem skrývá
a sám se o ně stará na pozadí. Nevýhodou tohoto přístupu je, že
uživatel „nevidí", co se děje. Například pokud se proměnná X exportuje
do ChaiScriptu jako reference a pak je ve skriptu vytvořená
nová proměnná Y příkazem varY = X, dojde ke kopii odkazované
hodnoty, nikoliv k vytvoření nové reference na původní hodnotu, což
by programátor nemusel očekávat.
Osobně se mi také příliš nelíbí, že rozhraní svádí k míchání C/C++
kódu a skriptu (hodnoty se z ChaiScriptu získávají jako vykonání
skriptu), což může vést k chybám neodhalitelným při kompilaci. Největší
jeho nevýhodou je však pomalost, a to jak běhu, tak kompilace.
ChaiScript se mi zdá být ideální v případě, že je třeba rychle vytvořit
prototyp komunikace mezi C/C++ a skript, jazykem, nebo v případě,
že je třeba do skriptu přesunout časově zcela nekritickou funkcionalitu,
ideálně v kombinaci s aplikací využívající sdílené ukazatele
(viz kapitola 2.1.2). Přestože primárním kritériem výběru je rozhraní
jazyka, kde ChaiScript vede, a výkon je až posledním kritériem, ChaiScript
pro plánovač nedoporučuji právě proto, že je řádově pomalejší
než ostatní testované jazyky.
47
4- OSOBNÍ ZKUŠENOSTI A CELKOVÉ VYHODNOCENÍ
4.2 Python
Python má ustálené a dobře dokumentované C rozhraní a díky tomu,
že jde o široce používaný jazyk, zpravidla není problém najít řešení
případných problémů. Výsledný kód je také poměrně dobře čitelný.
Nevýhodou C rozhraní Pythonu je pak nutnost zvyšovat a snižovat
reference (viz 2.2.2) vzhledem k tomu, že jediný způsob ke zjišztění, jak
se konkrétní funkce chová k referencím, je konzultovat dokumentaci,
tak je zejména při časté změně kódu poměrně jednoduché ztratit
přehled, což může vést ke špatně odhalitelným chybám.
Python považuji za vhodný do menších projektů, kde je snadné
udržet přehled o referencích, a díky spoustě existujících návodů je
snadné naučit se s ním pracovat. Pro některé projekty může být výhodou,
že nevnáší závislost na C++.
Za předpokladu, že se v plánovači budou exportovat pouze malé
a relativně nezávislé úseky kódu, by reference neměly představovat
problém. Python samotný bych pro plánovač nedoporučil kvůli způsobu
exportu tříd, který i pro zpřístupnění jednoduché funkcionality
vyžaduje zbytečně mnoho kódu. Tento problém by však mohlo vyřešit
použití některého z podpůrných nástrojů, pak by mohl být Python
dobrým kandidátem.
4.3 Lua
Lua má z pohledu C/C++ programátora velmi nezvyklé API. Ze
zběžného pohledu na kód je poměrně těžké si uvědomit, co se v něm
děje, neboť hodnoty jsou předávány pomocí zásobníku, a tak je třeba
pro správné pochopení kódu si v každém okamžiku udržovat přehled
o aktuální pozici všech prvků na zásobníku. Dovedu si ale představit,
že pro někoho, kdo je na tento přístup zvyklý, může být toto rozhraní
velmi pohodlné. Stejně jako Python je i Lua starší a ustálený jazyk, a
existuje pro něj tedy kvalitní dokumentace a dostatek publikací.
Lua se mi jeví jako ideální volba, pokud má být významnou částí
velmi rozsáhlého projektu, kde má pro programátora smysl zvykat si
na její unikátní rozhraní. Pro některé projekty může být výhodou, že
nevnáší stejně jako Python závislost na C++.
48
4- OSOBNÍ ZKUŠENOSTI A CELKOVÉ VYHODNOCENÍ
Ve většině testů Lua vykazuje velmi dobré výsledky a export třídy
je srovnatelně složitý jako u jiných jazyků až na nezvyklé rozhraní.
Ale protože jednoduchost a čitelnost rozhraní je primárním kritériem,
pro použití v plánovači nemohu jazyk Lua doporučit.
4.4 JavaScript V8
V8 má velmi pěkné a pohodlné, silně objektově orientované C++ rozhraní.
Kvůli rychlému vývojovému cyklu je ovšem poměrně obtížné
najít aktuální tutoriály a řešení případných problémů. Největší nevýhodou
je patrně poměrně strohá dokumentace. Navíc kvůli častým
změnám C/C++ rozhraní jsou v něm občas prvky, které jsou ponechány
jen z důvodu zpětné kompatibility. Při exportu třídy je u něj
nevýhodou oproti ostatním jazyků chybějící podpora typové kontroly.
S ohledem na složitější kompilaci, inicializaci a relativní nedostatek
dokumentace bych V8 nepoužil pro opravdu malé projekty, kde se
nevyplatí investovat čas do řešení úvodních problémů a seznámení
s jeho rozhraním. Jinak se mi V8 jeví jako dobrá volba, kdykoliv nevadí
jeho rychlý vývojový cyklus. Zdá se být dostatečně rychlý, aby
nepředstavoval výrazné zpomalení systému, ačkoliv při konverzi polí
zjevně poněkud zaostává za ostatními jazyky. Jeho silně objektově
orientované rozhraní se mi osobně jeví přehlednější a srozumitelnější
než více procedurální rozhraní konkurenčního SpiderMonkey, ačkoliv
to je značně subjektivní hodnocení.
Pro export malých funkcí a poměrně jednoduché funkcionality
potřebné pro plánovač by nedostatek tutoriálů neměl představovat
výrazný problém. Ze stejných důvodů by neměl být kritický pro stabilitu
či bezpečnost plánovače, proto by nemělo být nutné přecházet na
nové verze, a tudíž by ani rychlý vývojový cyklus V8 neměl být problémem.
Celkově tedy V8 považuji za dobrého kandidáta na použití
v plánovači.
4.5 JavaScript SpiderMonkey
SpiderMonkey je, co se používání týče, dost podobné V8. Na rozdíl od
V8 se ale na jeho C++ rozhraní více projevuje projevuje rychlý vývoj a
49
4- OSOBNÍ ZKUŠENOSTI A CELKOVÉ VYHODNOCENÍ
je méně koherentní . Také se mi více zamlouvá práce s Handle ve V8,
kde jsou přímo vraceny jako návratové hodnoty funkcí a není je třeba
explicitně „rootovat". Oproti V8 má však bohatší dokumentaci, většina
prvků obsahuje poměrně detailní popis a uvedeny jsou i rozdíly
mezi jednotlivými verzemi SpiderMonkey enginu.
SpiderMonkey bych doporučil v obdobných situacích jako V8.
Obecně na rozhodnutí mezi V8 a SpiderMonkey má asi největší vliv
porovnání jejich výkonu v časově nejkritičtějších oblastech konkrétního
projektu. V testovaných oblastech SpiedrMonkey zaostával jen
v testu volání skriptu, ale opět nijak extrémně. Protože primárním
hlediskem je rozhraní, kde jsou si V8 a SpiderMonkey až na rozdílnost
přístupu a drobné detaily podobné, hodnotím oba pro potřeby
plánovače jako ekvivalentně dobrou volbou.
1. Například některé funkce jsou součástí globálního jmenného prostoru a jiné jsou
ve jmenném prostoru JS.
50
5 Plánovač
Jak jsem uvedl již v úvodu, motivací této práce je prozkoumání možnosti
integrace skriptovacího jazyka do plánovače úloh dávkového
systému TORQUE. Abych mohl zohlednit potřeby plánovače v této
práci, musel jsem se s ním nejprve seznámit. Zkušenosti nabyté při
seznámení s ním jsem nakonec spojil se znalostmi a zkušenostmi
nabytými při porovnávání jazyků k vytvoření ukázky integrace skriptovacího
jazyka do plánovače.
5.1 Rozšíření konfigurace plánovače
Abych se seznámil s vnitřní strukturou plánovače a jeho potřebami, dostal
jsem dva úkoly. Plánovač původně načítal konfiguraci z textového
souboru při svém spuštění a bylo nezbytné jej při změně konfigurace
restartovat. Mým prvním úkolem proto bylo rozšířit jej o schopnost
načítat změny konfigurace za běhu. Druhým úkolem bylo nahradit
některé konstanty ze souboru sched_config.h a pole z sched_limits.cpp
novými volbami v konfiguračním souboru.
5.1.1 Dynamické načítání konfigurace
Konfigurační soubor čte funkce parse_config() definovaná v parse.cpp
a hodnoty z něj ukládá do globální proměnné conf typu struct config.
Abych mohl detekovat změnu konfigurace, přidal jsem sem i čas modifikace
konfiguračního souboru. Na začátek plánovacího cyklu v metodě
plan_run() definované v SchedulerRealm.cpp jsem přidal funkci
kontrolující, zda došlo ke změně konfiguračního souboru, a načtení
nové konfigurace v případě jeho změny.
5.1.2 Rozšíření konfigurace
Ve druhé části jsem přidal nové konfigurační volby do funkce parse_
configQ. Přidání konstant z sched_config.h bylo triviálním rozšíření
této funkce a přidáním těchto položek do struktury config. Přidání
polí z sched_limits.cpp bylo poněkud komplikovanější, neboť původní
formát konfiguračního souboru neměl prostředky pro definici pole
51
5- PLÁNOVAČ
hodnot. Navíc bylo požadováno, aby bylo možné definovat kromě
společné konfigurace, která byla původně v těchto konstantních polích
uložena, i specifické konfigurace pro různé kombinace clusteru
a počtu cpu. Proto jsem po konzultaci s vývojáři plánovače definoval
vlastní formát pro reprezentaci požadované konfigurace a vlastní
funkci parse_limit() zpracovávající jejich konfiguraci.
Funkce parse_config() načítá soubor po řádcích a postupně je zpracovává.
Protože se přitom mění obsah právě zpracovávaného řádku
způsobem neslučitelným s mnou zvoleným formátem, ukládám kopii
původní hodnoty volby, a pokud volba definuje pole, přenechávám
její zpracování metodě parse_limit{), které předávám uloženou kopii
hodnoty.
Formát, který jsem použil pro konfiguraci polí, umožňuje zadat
konfiguraci pro konkrétní kombinaci clusteru a počtu cpu. Opakované
zadání konfigurační volby pro stejnou kombinaci clusteru a počtu
cpu je považováno za pokračování dřívější volby. To umožňuje zadávat
hodnoty na několika řádcích a zlepšuje tak čitelnost konfigurace
dlouhých polí.
Aby nebylo nutné v konfiguračním souboru dopředu explicitně definovat
velikost polí, ukládám je do dynamických C++ kontejnerů. Do
struktury config, do níž se konfigurace ukládá, jsem přidal ukazatele
na tyto kontejnery. Ukazatele jsem použil z důvodu, že k inicializaci
config je použito vynulování paměti pomocí funkce memset a to by
narušilo vnitřní konzistenci kontejnerů, pokud by byly přímo součástí
této struktury. Musel jsem také upravit její inicializaci a uvolnění a
přidat do ní alokaci a dealokaci použitých kontejnerů.
5.1.3 Získané zkušenosti
Při plnění těchto úloh jsem zjistil, že plánovač zpravidla používá
k uchování informací C struktury. Jednoduchost exportu C struktury
tak bude mít důležitou roli při hodnocení skriptovacích jazyků. Tyto
struktury jsou v plánovači zpravidla alokovány dynamicky a často se
vzájemně odkazují pomocí ukazatelů nebo polí ukazatelů. Alokace a
dealokace těchto struktur bývá netriviální a provádí se pomocí speciálních
funkcí. Pokud by tedy vyvstala potřeba tyto struktury alokovat
a dealokovat ze skriptu, bude třeba také exportovat patřičné funkce.
52
5- PLÁNOVAČ
5.2 Integrace skriptovacího jazyka
Pro implementaci ukázky integrace do plánovače jsem si zvolil V8
engine, který se mi jeví jako jedna z vhodných možností, jak uvádím
v kapitole 4.
Plánovač používá k průběžné optimalizaci plánu, podle něhož
spouští jednotlivé úlohy, algoritmus lokálního prohledávání. Pro jeho
výpočet potřebuje spočítat tzv. účelovou (též evaluační) funkci. Pro
potřebu této ukázky jsem z funkce plan_optimization() (definovaní
v plan_optimization.cpp) exportoval výpočet této funkce do skriptovacího
jazyka. Data používaná pro výpočet této funkce plánovač ukládá
ve struktuře plan_eval. Exportoval jsem proto tuto strukturu1
dle postupu
z kapitoly 2.4.7.
weight_slowdown = (1.0 * (evaluation_before.slowdown evaluation_after.slowdown))
/ evaluation_before.slowdown;
weight_wait_time = (1.0 * (evaluation_before.wait_time evaluation_after.wait_time))
/ evaluation_before.wait_time;
weight_response_time = (0.0 *
(evaluation_before.response_time evaluation_after.response_time))
/
evaluation_before.response_time;
weight_fairness = (10.0 * (evaluation_before.fairness evaluation_after.fairness))
/ evaluation_before.fairness;
if (weight_slowdown + weight_wait_time + weight_response_time
+ weight_fairness > 0) {
Ukázka 5.1: Původní výpočet evaluační funkce z plan_
optimization.cpp
Původní výpočet účelové funkce (viz Ukázka 5.1) jsem nahradil
voláním vlastní funkce js_eval(evaluation_before, evaluation_after),
její argumenty jsou dvě instance struktury plan_eval, tato funkce je
konvertuje a zavolá JS funkci eval_plan() z plan_eval.js (viz Ukázka
1. Fakticky jsem neexportoval úplně všechny její atributy, některé pro výpočet
funkce nepotřebné jsem vynechal.
53
5- PLÁNOVAČ
k příloze A.2.4). Jak je vidět na ukázkách, výpočet evaluační funkce v JS
funkci je zcela identický s původním výpočtem. Výhodou exportované
funkce však samozřejmě je, že je možné ji kdykoliv změnit bez nutnosti
kompilace, zejména umožňuje dynamicky měnit váhy jednotlivých
kritérií účelové funkce. Abych ověřil správnost výsledku exportované
funkce, ponechal jsem v plánovači i původní výpočet a jejich výsledky
porovnávám.
Vytvořil jsem také funkci js_init(), která zajistí inicializaci V8 a načte
soubor se skriptem. Volání této funkce jsem vložil na začátek plánovacího
cyklu (viz kapitola 5.1.1), což zajišťuje, že se v každém cyklu
provádí aktuální funkce, ale zároveň není třeba číst soubor se skriptem
při každém volání funkce.
Celou implementaci exportu jsem umístil do nového souboru
js_v8.cpp a hlavičkového souboru js_v8.h, který obsahuje deklarace
funkcí js_eval() ajs_init() a souboru plan_eval.js obsahujícího definici
JS funkce (viz přílohy A. 2).
54
6 Závěr
V této práci jsem popsal a porovnal možnosti integrace skriptovacích
jazyků ChaiScript, Python, Lua a dvou implementací jazyka JavaScript,
konkrétně V8 a SpiderMonkey, do C/C++ aplikace. Abych mohl zohlednit
potřeby plánovače dávkového systému TORQUE, jenž je motivací
této práce, využil jsem zkušenosti, jež jsem získal při rozšiřování
možností jeho konfigurace.
Pro testované jazyky jsem popsal, jak náročné je začít je vůbec
používat a jak se v nich pracuje s pamětí. Také jsem popsal převod
jednoduchých hodnot mezi nimi a C/C++, export C/C++ funkce do
testovaných jazyků a volání jejich funkcí z C/C++. S ohledem na potřeby
plánovače jsem se podrobně zabýval exportem komplexních C++
typů. Upozornil jsem na problémy spojené s manipulací s pamětí ze
skriptovacího jazyka. Také jsem ukázal několik příkladů nástrojů, jež
mohou zjednodušit integraci skriptovacího jazyka do C/C++, a upozornil
jsem na některé problémy s nimi související.
Pro uvedené jazyky jsem vytvořil sadu testů, ve které jsem porovnal
jejich výkon při volání funkcí ať již definovaných v C/C++, či ve
skriptu, a též jejich výkon při přenosu dat z C/C++ do skriptovacího
jazyka a při manipulaci s těmito daty.
Výsledky testů a své zkušenosti s těmito jazyky jsem využil k tomu,
abych jednotlivé jazyky zhodnotil a navrhl 3 možné kandidáty pro
integraci do plánovače. Z navržených kandidátů jsem si zvolil V8
engine a ukázal jsem jeho možnou integraci do plánovače v praxi.
Cílem této práce bylo ukázat a popsat možnosti integrace skriptovacích
jazyků do C/C++ aplikace, a proto dalším zřejmým krokem
by bylo využití zde popsaných postupů a zkušeností při integraci
některého ze zmíněných jazyků ať již do plánovače, jenž vznik této
práce motivoval, tak do jiné C/C++ aplikace.
55
Literatura
[1] Stefan Behnel, Robert Bradshaw, Dag Sverre Seljebotn, Greg
Ewing, William Stein, Gabriel Gellner, et al.. Cython documentation.
Dostupne z http: //does. cython. org/index. html. [cit.
28.12.2015].
[2] Boost.python. Dostupne z http://www. boost.org/doc/libs/l_
58_0/libs/python/doc/index.html. [cit. 2. 5. 2016].
[3] Cerit scientific cloud. Dostupne z http: //www. c e r i t - s c . cz/cs/.
[cit. 2. 5. 2016].
[4] Mozilla Contributors. M d n . Dostupne z https ://developer.
mozilla.org/en-US/docs/Mozilla/Proj ects/SpiderMonkey.
[cit. 28. 12. 2015].
[5] The SWIG Developers. Swig-3.0 documentation. Dostupne z
http://swig.Org/Doc3.0/SWIGDocumentation.html. [cit. 28.12.
2015].
[6] Python Software Foundation. Python. "Dostupne z https: / /
www.python.org. [cit. 28. 12. 2015]".
[7] Python Software Foundation. Python 3.4.4 documentation. "Dostupne
z https : //docs. python. org. [cit. 28. 12. 2015]".
[8] Google. Chrome v8. online. Dostupne z https: //developers.
google. com/v8. [cit. 28. 12. 2015].
[9] Google benchmark. Dostupne z https: //github. com/google/
benchmark, [cit. 4. 1. 2016].
[10] Ierusalimschy, R. Programming in Lua. Roberto Ierusalimschy,
2013.
[11] Jonathan Turner Jason Turner. Chaiscript. Dostupne z http:
/ / c h a i s c r i p t . com/, [cit. 2. 5. 2016].
[12] Pierre Krieger. Tomaka's lua wrapper. Dostupne z https: / /
github.com/ahupowerdns/luawrapper. [cit. 28. 12. 2015].
57
LITERATURA
[13] Lua. Dostupné z http: //www. lua. org. [cit. 28. 12. 2015].
[14] PUC-RioLua.org. Lua 5.3 reference manual. Dostupné z http:
//www.lua.org/manual/5.3/. [cit. 28. 12. 2015].
[15] Mark Pilgrim. Dive Into Python 3. Apress, Berkely, CA, USA, 2009.
58
A Obsah přiloženého DVD
A.l Výkonostní testy
Součástí této práce jsou též zdrojové soubory výkonových testů použitých
v kapitole 3.
A.1.1 práce_s_pametí_a_volání_skriptu.ods
Soubor s úplnými výsledky výkonnostních testů z kapitol 3.2 a 3.3.
A.1.2 volání_exportovných_funkcí.ods
Soubor s úplnými výsledky výkonnostních testů z kapitoly 3.1.
A.2 Úpravy plánovače
Součástí této práce jsou též úpravy, které jsem provedl na plánovači
úloh systému TORQUE popsaných v kapitole 5. Část je jich již součástí
repositáře plánovače. Zbytek je přiložen ve formě dvou „.patch"
souborů (0001 — úpravy.patch a 0002 — úpravy .patch). Implementaci
integrace JavaScriptu přikládám i samostatně (viz níže).
A.2.1 troque_fast_sched-git.txt
Soubor obsahující odkaz na Git repositář plánovače a commit, na nějž
je třeba aplikovat výše zmíněné patche.
A.2.2 js_v8.cpp
Samostatně přiložený zdrojový soubor s implementací exportu.
A.2.3 js_v8.hpp
Samostatně přiložený hlavičkový soubor s implementací exportu.
59
A . OBSAH PŘILOŽENÉHO D V D
A.2.4 plan_eval.js
Samostatně přiložený hlavičkový soubor s implementací evaluační
funkce v JavaScriptu. Pro snadnější čitelnost také uvádím na ukázce
níže.
60
A . OBSAH PŘILOŽENÉHO D V D
function eval_plan ( evaluation_before,
evaluation_after){
weight_slowdown = (1.0 *
(evaluation_before.slowdown evaluation_after.slowdown))
/
evaluation_before.slowdown;
weight_wait_time = (1.0 *
(evaluation_before.wait_time evaluation_after.wait_time))
/
evaluation_before.wait_time;
weight_response_time = (0.0 *
(evaluation_before.response_time evaluation_after.response_time))
/
evaluation_before.response_time;
weight_fairness = (10.0 *
(evaluation_before.fairness evaluation_after.fairness))
/
evaluation_before.fairness;
return weight_slowdown + weight_wait_time +
weight_response_time + weight_fairness;
}
Ukázka A . l : plan_eval.js