Bonyolultsági mértékek szoftverek méréséhez oktatási segédlet

Átírás

1 Bonyolultsági mértékek szoftverek méréséhez oktatási segédlet Király Roland TÁMOP A/ Nemzeti Kiválóság Program Jedlik Ányos Doktorjelölti Ösztöndíj a konvergencia régiókban pályázat Bonyolultsági mértékek elemzése A mértékeket egy speciális adatszerkezet, a szemantikus gráf SG (lásd.: [10] cikkben) elemzése során gyűjtött információk felhasználásával számítjuk ki. Értékes sorok száma Az effective_lines_of_code a kódrészlet, konkrétabban a függvény, vagy modul azon sorainak számát adja, amelyek forrásszöveget tartalmaznak. Az effective jelző tehát azt jelenti, hogy az eredményben nem szerepelnek sem az üres, sem a kommenteket tartalmazó sorok. 1. Definíció. [effective_lines_of_code] Jelölje a forrásszöveg összes sorát L(M), és a csak kommenteket tartalmazó sorokat K(M) (K(M) L(M)). Ekkor a forrásszöveg értékes sorainak a száma, vagyis az: ELOC(M) := L(M) \ K(M). A mérték alkalmazható az SG gráf tetszőleges moduljára: ELOC(m i ) := L(m i ) \ K(m i ), és használhatjuk modulok egy csoportjának mérésére is: ELOC(m 1,..., m k ) := ELOC(m i ). Mindezek mellett az ELOC mértéket alkalmazhatjuk függvények egy csoportjára ELOC(f 1,..., f k ) is. A mért függvények több modulból is kikerülhetnek. Az egyetlen kikötés, hogy az SG szemantikus gráf tartalmazza azokat. Fontos megjegyezni, hogy a ELOC(m i ) ELOC(F (m i )), vagyis a modulra mért érték nem azonos a függvényeire mért eredmények összegével, mivel a modul a függvények lexikális elemein kívül tartalmazhat rekordokat, makrókat, és egyéb elemeket. i=1 1

2 Átlagos sor hossz Az average_length_of_line mérték az adott függvényben, vagy modulban található sorok hosszának az átlagát adja vissza. (A strukturált bonyolultság lekérdezésére kifejlesztett (és a??. fejezetben bemutatott) nyelvtan segítségével, a max_length_of_line mértékhez hasonlóan ez az érték is előállítható, ha alkalmazzuk annak avg, vagy sum nevű filtereit, de a belső interface számára fontos, hogy a mértékek külön is szerepeljenek.) Ez a mérték annak ellenére, hogy nem tűnik fontosnak, nem kihagyható, mivel az egyes programozók, és cégek programjaiknál előírják az átlagos sorhosszok alkalmazását, valamint a forrásszöveg olvashatóságát rossz irányba befolyásolhatják a túl hosszú sorok. Az eredmény kiszámításához a ELOC mértéket kell alapul vennünk, és a??.1. definícióban leírtak szerint ki kell számítanunk a sorok hosszát, majd a kapott eredményt átlagolnunk, vagyis az ALOL(M) = ELOC(M) CHOC(M). Az ALOL mérték nem veszi figyelembe az eredmény meghatározása során az üres, vagy a kizárólag kommenteket tartalmazó sorok hosszát. A szemantikus gráf bejárása szintén azonos az ELOC mértéknél bemutatottal. A mértéket alkalmazhatjuk függvények, vagy modulok mérésére is, de fontos megjegyezni, hogy az ALOL(m i ) ALOL(F (m i )) vagyis a függvények átlagos sorhossza nem azonos a modul átlagos sorhosszával. Karakterek száma A chars_of_code a programszöveg karaktereinek számát adja vissza. A mérés során kapott érték nem tartalmazza a kommentek jeleinek a számát, valamint nincs benne a sortörés, és egyéb white space karakterek száma sem. 2. Definíció. [chars_of_code] Ha L(M) a forrásszöveg összes sora, és K(M) a csak kommenteket tartalmazó sorok, S = L(M)\K(M) az értékes sorok halmaza, s i S ennek a halmaznak egy eleme, w i az s i sorban található kommentek, és white space karaktereinek halmaza, és n = S, akkor CHOC(M) = n ( s i w i ) i=1 A mérték az effective_lines_of_code-hoz hasonlósan alkalmazható függvények csoportjára CHOC(f 1,..., f j ), de használhatjuk egy modul COC(m i ), vagy modulok egy csoportjának COC(m 1,..., m j ) mérésére. Mivel a CHOC mérték alapja a sorok, és a sorok jeleinek a száma, itt is igaz, hogy a CHOC(m i ) CHOC(F (m i )), vagyis a modulra mért összesített érték nem azonos a függvényeire mért eredmények összességével. A mérték kiszámításához szükséges gráf útvonal azonos a effective_lines_of_code mértéknél definiálttal, de itt az útvonalak bejárásával kapott csomópontokban talált lexikális elemek jeleinek számát kell összegezni ahhoz, hogy az eredményét megkapjuk. 2

3 1. Állítás. Jelölje a megfelelő gráfútvonalon kapott eredmény listát L, jelölje az L egy p eleméhez kötött kommentek jeleinek számát c(p), valamint az ugyanezen elemekhez kötött akárhány sorvége jelek számát db(p ), és a p A által reprezentált forrásszöveg elemeinek hosszát length(p). Ekkor a mérték eredménye, vagyis CHOC(M) = p L(length(p) c(p) db(p )). Függvények száma A number_of_functions mérték a modulokban definiált függvények számát adja vissza. Ez a mérték különösen releváns funkcionális programok jellemzése során, mivel azok nagy számban tartalmaznak függvény konstrukciókat, így a lines_of_code mellett, annak használatával következtethetünk a modulok méretére. 1. Megjegyzés. Az -import(m,f). formulával láthatóvá tett függvényeket, valamint az F (M) függvényei által hívott függvények számát a mérték nem tartalmazza, a i : m : f(e 1,..., e n ) vagy f(e 1,..., e n ) valamint a több ággal (clause) rendelkező függvények ágait nem számolja bele az összesített értékbe. Az m : f(e) formula a minősített hívásokat jelöli, f(e) pedig a más modulokból importált, valamint a mért modulban hívott függvényeket, e és e i E tetszőleges kifejezések, amelyek a meghívott függvény aktuális paraméterei. 3. Definíció. [number_of_f unctions] A mérték eredménye az SG szemantikus gráfban szereplő összes modulra NOF (M) = F (M). A mérték segítségével mérhetünk egy modult NOF (m i ) = F (m i ), vagy modulok egy csoportját NOF (m 1,..., m k ) = F (m i ). i=1 Makrók száma A number_of_macros mérték az adott modulban, vagy modulokban definiált makrók, pontosabban makró definíciók számát adja meg. 2. Megjegyzés. Makró definíciók: def 1 (v 1, e 1 ).. def t (v t, e t ). 3

4 makró definíciók, ahol v i V makró nevek, és e i E kifejezések, amelyeket a makró nevére hivatkozva érhetünk el azokban a modulokban, ahol a makró definíciója látható. 4. Definíció. [number_of_macros] Az m i M modul által tartalmazott makró definíciókat jelölje D(m i ) := {def 1,.., def t }, ahol def i egy makró definíció. A D(m i ) a fejléc fájlokkal láthatóvá tett makró definíciókat nem tartalmazza. Ekkor a mérték eredménye az összes modulra NOM(M) = m M D(m). A mérték használható egy modulra: NOM(m i ) = D(m i ), és alkalmazható modulok egy csoportjára is NOM(m 1,..., m k ) = D(m j ). j=1 Rekordok száma A number_of_records mérték az adott modulban definiált rekordok számát adja vissza. A rekordok használatának lehetősége sok esetben olvashatóbbá, de mindenképpen alakíthatóbbá teszi a forrásszöveget azáltal, hogy a rekordokat használhatjuk a függvény paraméterek dinamikusabbá tételére. A rekord update [?] mechanizmus alkalmazásával a rekordokat a függvények formális paramétereként használva, a paraméter lista aktualizálása során nem kell minden rekord mezőt szerepeltetnünk, és a rekord mezők bővítésével a függvények paraméterezésének átalakítása nélkül adhatunk extra információt a függvény ágakhoz, más ágak megváltoztatása nélkül. Mintaillesztés során tuple mintára illeszthetünk rekordokat, és ez fordítva is történhet azzal a megkötéssel, hogy az n-es első eleme meg kell egyezzen rekordnévvel. Mindezek miatt a rekordok fontos szerepet kapnak a bonyolultság vizsgálata során. 3. Megjegyzés. A rekordok definíciója a modulok első szakaszában szerepelhet a következő formában: rec 1 (n 1, f 1 1 [= v 1 1],..., f 1 n[= v 1 n]).. rec t (n t, f t 1[= v t 1],..., f t n[= v t n]). Ahol rec i R rekord definíciók, n i N rekord nevek, f j i a rekord mezőinek a nevei, és v j i (opcionális) a mezők értékei. 5. Definíció. [number_of_records] Az m i M modul által tartalmazott makró definíciókat jelölje R(m i ) := {rec 1,.., rec t }, ahol rec i egy rekord definíció. A R(m i ) a fejléc fájlokkal láthatóvá tett makró definíciókat nem tartalmazza. Ekkor a mérték eredménye az összes modulra NOR(M) = m M R(m). 4

5 A mérték használható egy modulra: NOR(m i ) = R(m i ), és alkalmazható modulok egy csoportjára is NOR(m 1,..., m k ) = R(m j ). j=1 Fejléc fájlok száma A number_of_headers mérték a modulban szereplő fejléc fájlok számát adja vissza. A több modul függvényei által közösen használt adatokat, rekordokat, makrókat, vagy szélsőséges esetekben függvényeket fejléc fájlokba rendezik, majd ezeket a fájlokat az include(filepath) formában elérhetővé teszik modulok számára. E mechanizmus miatt a programokban fontos szerephez jutnak, mivel a modulok kapcsolatrendszerét, a hívási gráfokat, és adatfolyam analízisek eredményeit befolyásolhatják. 6. Definíció. [number_of_headers] Jelölje H = {h 1,..., h k } a fejléc fájlokat (*.hrl), és A = M H, valamint jelölje az include(x, y) azt, ha x M az include(filepath) formában láthatóvá teszi az y A fájlt. Ekkor In(M) = {(x, y) y A x M include(x, y) x y} esetén NOH(M) = In(M). 1. Magyarázat. Az include(x, y) formulában megengedjük azt az esetet, amikor egy modul egy másik modult tesz láthatóvá. A mérték alkalmazható modulok egy csoportjára NOH(m 1,..., m k ) = In(m i ), i=1 ahol In(m i ) = {(m i, y) y A include(m i, y) m i y}. Importált modulok Az imported_modules mérték az adott modulba (nem rekurzívan) importált más modulok számát adja vissza. Az import modulok száma arra világíthat rá a mérések során, hogy a mérésben szereplő modulok milyen szoros, vagy éppen laza kapcsolatban állnak egymással. Ez a fajta mérés fontos lehet annak az eldöntésében, hogy egy modul klaszterezési eljárás során egy modul a kapcsolatrendszer alapján mely csoportoknak legyen tagja. A mérték nem tartalmazza a minősített hívások (module:function alakú hívások) számát. 7. Definíció. [imported_moduls] Az m i M modul által importált modulokat jelölje I(m i ). Kikötjük, hogy m i / I(m i ), valamint a rekurzívan importált modulokat nem számoljuk az eredménybe. Ekkor az. IM(M) = m M I(m) 5

6 A mérték alkalmazható egy modul mérésére IM(m i ) = I(m i ), valamint modulok egy csoportjának a mérésére: IM(m 1,..., m k ) = I(m i ) i=1 Kohézió A cohesion nevű mérték a modulok közötti összes függvény útvonal számát adja eredményül, de a belső függvény kapcsolatok számát nem méri. 4. Megjegyzés. Az m i M modulokban található függvény hívásokat két esetben tekinthetjük modulok közti függvény útvonalnak: Az első eset, ha a kapcsolatban szereplő függvény moduljára igaz, hogy tartalmazza a hívó, de nem tartalmazza a hívott f app i függvény definícióját. A másik eset, ha az m i nem tartalmazza a hívó, de tartalmazza a hívott függvény f i definícióját. f app i 8. Definíció. [függvényhívási kapcsolat] Az m i M modulok tartalmazhatnak függvény definíciókat. Minden f i, f j F (M), f i f j párra keressük meg, hogy f i, és f j között van e hívási kapcsolat. Kapcsolat alatt azt értjük, hogy f i hívja f j függvényt, és ezt a következőképp jelöljük: c(f i, f j ). Az összes ilyen kapcsolat halmazát jelölje C(F (M)) = {(f i, f j ) f i, f j F (M) f i f j c(f i, f j )}. Az m i modulból kifelé tartó függvényhívások jelölése C(m i, F (M)) = {(f i, f j ) f i F (m i ) f j F (M) f i f j c(f i, f j )}. Az m i modulba tartó összes hívás jelölése C(F (M), m i ) = {(f i, f j ) f i F (M) f j F (m i ) f i f j c(f i, f j )}. Az adott modul egy függvényére az SG szemantikus gráfból érkező összes függvényhívást jelölje C(F (M), f j ) = {(f i, f j ) f i F (M) f i f j c(f i, f j )}. Adott függvényből kifelé irányuló függvényhívásokat jelölje C(f i, F (M)) = {(f i, f j ) f j F (m i ) f i f j c(f i, f j )}. Az m i modul belső függvényhívásai C(F (m i ), F (m i )) = {(f i, f j ) f i, f j F (M) f i f j c(f i, f j )}. 6

7 5. Megjegyzés. Amennyiben a 8. definíció alapján a c(f i, f j ), és c(f j, f i ) is fennáll, vagyis a függvények kölcsönösen hívják egymást, a kapcsolatok száma kettő. Ha egy függvény többször hív egy másikat függvényt, ezek a kapcsolatok egy útvonalnak számítanak. 9. Definíció. [cohesion] A kohéziós mérték COH(M) = C(F (M)) m M C(F (m), F (m)). A kohézió szempontjából az SG szemantikus gráfban található összes függvénykapcsolatból kizárjuk az olyanokat, ahol a függvényhívás ugyanabból a modulból indul ki, és oda is tart. Összetartó erő A coupling mérték a modulban található függvények közötti hívási kapcsolatok számát adja eredményül. A belső függvény kapcsolatok számát igen, de a kívülről jövő, vagy a modulból kifelé tartó utak számát nem, vagyis csak a belső hívások számát tartalmazza. 6. Megjegyzés. app i : m i : f(e 1,..., e n ) vagy m i : f(e 1,..., e n ) függvényhívások ahol m i a mért modul, m i : f(e 1,..., e n ) a modul függvényének minősített hívása, és f(e 1,..., e n ) a függvény hívása m i modulból. e 1,..., e n kifejezések a függvény aktuális paramétereként, és n a hívott függvény paramétereinek a száma. 10. Definíció. [coupling] A coupling mérték CP (m i ) = C(F (m i ), F (m i )). Modulba irányuló függvényhívások száma A function_calls_in mérték minden, a modul függvényeire irányuló, de külső modulból érkező függvényhívás (application) számát méri. 11. Definíció. [f unction_calls_in] Az összes, az adott modulba irányuló függvényhívások száma F CI(m i ) = C(F (M), m i ). Modulból kifelé tartó függvényhívások száma A function_calls_out mérték minden, a modul függvényeiből induló, és más modulok felé irányuló függvényhívások számát adja vissza. 7

8 12. Definíció. Az m i modulból kifelé irányuló függvényhívások száma, F CO(m i ) = C(m i, F (M))). Függvény hívási mélység maximuma A max_depth_of_calling mérték a függvények hívási útvonalainak a hossza. (Az eredmény nem azonos rekurzív hívások legnagyobb mélységével, azokat a max_depth_of_recursion függvény szolgáltatja.) A működés megértéséhez segítségünkre lehet a 1 példa, ahol mért legnagyobb hívási mélység három.... f([a B], Acc) -> Acc0 = exec(a, Acc), f(b, );s f([], Acc0)-> acc0. exec(a, Acc)-> io:format("~w",[a]), A + Acc.... Hívási mélység 1. ábra. Függvények hívási mélysége 13. Definíció. [függvényhívási lánc hossza] A c(f i, f j ) pár egyben hívási lánc, melynek hossza egy. Jelöljön egy f i függvényből kiinduló hívási láncot l(f i, f j ), ha f 1, f 2,...f m, hogy c(f i, f 1 ) c(f 1, f 2 )... c(f m, f j ), és f F (M), hogy c(f j, f), vagyis f j nem tartalmaz függvényhívást. Ekkor az l(f i, f j ) = m Definíció. [max_depth_of_calling] Legyen L(f i ) = {l(f i, f k ) f k F (M), f i f k } az f i -ből induló hívási láncok halmaza. Ekkor a függvény hívási mélység maximuma MDOC(f i ) = max{ l(f i, f k ) l(f i, f k ) L(f i )} A mértéket alkalmazhatjuk egy függvényre, függvények egy csoportjának MDOC(f 1,..., f k ) = max k MDOC(f i ), i=1 8

9 valamint alkalmazhatjuk modulok mérésére is. A modult jellemző hívási lánc maximuma megegyezik a modul függvényeire mért hívási láncok maximumával, ahol: MDOC(m i ) = MDOC(F (m i )) Az eredmény az összes modulra mérve: MDOC(M) = max n M MDOC(m). Case kifejezések maximális beágyazottsága A max_depth_of_cases a függvényben, vagy a modul függvényeiben szereplő case vezérlő szerkezetek beágyazottságának maximuma. Beágyazottság... case Data of {Pid, D} -> D! Pid; _ -> case Data of... end end ábra. Case kifejezések egymásba ágyazása A case kifejezéseket mérésekor nem azok számát, hanem a beágyazottságukat kell vizsgálnunk, hasonló módon, mint a függvény hívási mélység esetén. c 0 : case e of p 1 [when g 1 ] e 1 1,..., e 1 l 1 ;. p n [when g n ] e n 1,..., e n l n end Ahol e, e i E kifejezések, p P minták g i G őr feltételek az ágakban. A case kifejezések ágaiban az e i j kifejezések tartalmazhatnak beágyazott vezérlő szerkezeteket, többek között újabb case kifejezéseket. 15. Definíció. [max_depth_of_cases] Jelöljük T (f i )-vel az f i függvényben található összes case kifejezés halmazát. Jelölje t(c 1, c 2 ) azt, ha c 1 case kifejezés valamely ága tartalmazza c 2 case kifejezést, és c 3 case kifejezés, hogy t(c 1, c 3 ) t(c 3, c 2 ). 9

10 Jelölje t s (c, c x ) azt az esetet, hogy a c case kifejezés valamely ágában valamely mélységben tartalmazza a c x case kifejezést, vagyis c 1,..., c n case kifejezések, hogy t(c, c 1 ), t(c 1, c 2 ),..., t(c n 1, c n ), t(c n, c x ). A t s (c, c x ) beágyazás mélysége ez esetben n + 1. Legyen T 0 (f i ) azon case kifejezések halmaza, amelyeket egyetlen T (f i ) halmazbeli case kifejezés sem tartalmaz (felső szintű case kifejezések). Ekkor az MDC(f i ) = max{ t s (c, c x ) c T 0 (f i ), c x T (f i )}. A mértéket alkalmazhatjuk egy függvényre, függvények egy csoportjára MDC(f 1,..., f j ) = max k MDC(f i ), valamint modulok mérésére is, ahol a modult jellemző beágyazottság maximuma megegyezik a függvényeire mért maximummal: Az eredmény az összes modulra mérve: i=1 MDC(m i ) = MDC(F (m i )) MDC(M) = max{mdc(m i ) m i M} Kifejezések maximális beágyazottsága A max_expr_depth mérték az adott függvény függvényben szereplő vezérlőszerkezetek, vagy egyéb kifejezések (üzenet küldő, fogadó kifejezések, függvény kifejezések,...) egymásba ágyazottságának mértékét méri, és a maximumát adja. A mérték kiszámítása közel azonos a max_depth_of_cases mértéknél látottakkal, annyi különbséggel, hogy a definícióban, valamint a kiszámításhoz szükséges útvonal kifejezésben nem csak a case kifejezéseket, hanem if, try, f unction, és egyéb a programokban szereplő kifejezések beágyazottságát vizsgáljuk. 16. Definíció. [max_expr_depth] Jelölje t s (k, k x ) azt az esetet, hogy a k kifejezés valamely mélységben tartalmazza a k x kifejezést, vagyis k 1,..., k n kifejezések, hogy t(k, k 1 ), t(k 1, k 2 ),..., t(k n 1, k n ), t(k n, k x ). A t s (k, k x ) beágyazás mélysége ez esetben n + 1. Legyen T 0 (f i ) azon kifejezések halmaza, amelyeket egyetlen T (f i ) halmazbeli kifejezésbe sincsenek beágyazva (felső szintű kifejezések). Ekkor az MED(f i ) = max{ t s (k, k x ) k T 0 (f i ), k x T (f i )}. A mértéket alkalmazhatjuk egy függvény M ED(f), függvények egy csoportjának MED(f 1,..., f j ), valamint modulok mérésére is, ahol a modult jellemző beágyazottság maximuma megegyezik a függvényeire mért maximummal: MED(m i ) = MED(F (m i )) 10

11 Az eredmény az összes modulra mérve: MED(M) = max{med(m i ) m i M} Függvény ágak száma A number_of_funclauses mérték a függvény clauseainak (ágainak) a számát adja. A függvény definícióját, és minden ágat az eredményhez számolunk. Azonos nevű, de más aritású függvényeket nem adjuk az összeghez kell különbözniük. Ekkor a két azonos nevű függvény teljesen független egymástól). Mindezek alapján a 3 példában a number_of_funclauses értéke kettő, mivel az f függvény egy, és két paraméteres formában két különböző függvénynek számít. A programokban a case, valamint az if vezérlő szerkezetek helyett a több ággal rendelkező, (overload) függvények alkalmazása megszokott módszer. Azonos nevű függvények -export([f/2, f/1]). f(fun, [H Tail])-> Fun(H), f(tail); f(_, [])-> ok. f(a)-> A ábra. Fügvény klózok száma A függvények (hasonlóan az Objektum Orientált nyelvek overload metódusaihoz) több ágból állhatnak, ahol az ágakat a formális paraméterlista, vagy az ágak őrfeltételei különböztetnek meg egymástól. A number_of_funclauses mérték egy függvényt alkotó ágak számát adja eredményül. 17. Definíció. [number_of_funclauses] Jelöljük F c(f i )-vel az f i függvény ágainak halmazát. Ekkor a mérték eredménye az F c(f i ) halmaz számossága, vagyis az NF CL(f i ) = F c(f i ). A mérték alkalmazható egy NF CL(f), vagy több függvényre ágainak a megszámlálására NF CL(f 1,..., f k ) = NF CL(f i ) j=1 11

12 egyaránt, de mérhetjük vele a modulokban definiált összes függvény ágainak a számát is, ami megegyezik a modul függvényeiben található összes ágak számával, vagyis az NF CL(m i ) = NF CL(F (m i )), ahogy az összes modulra mért eredmény megegyezik az egyes modulokban mért eredmények összegével: NF CL(M) = NF CL(F (m i )). m i M 7. Megjegyzés. Az SG szemantikus gráfban a függvény első, - vagy egy ág esetén az egyetlen ágát - a függvény definíciójának tekintjük, a mérték kiszámítása során azonban minden ágat klóznak számolunk. McCabe féle ciklomatikus szám A mc_cabe bonyolultság mérték értéke a Thomas McCabe által konstruált vezérlési gráfban [1] definiált alapvető útvonalak számával azonos, vagyis azzal, hogy hányféle kimenete lehet egy függvénynek nem számítva a benne alkalmazott további függvények bejárási útvonalainak a számát. A Mc Cabe ciklomatikus számot eredetileg a procedurális nyelvek alprogramjainak a mérésére fejlesztette ki Thomas J. Mc Cabe [1]. Ez a mérőszám alkalmas a funkcionális nyelvek, így a modulokban implementált függvények mérésére is. Mc Cabe a programok ciklomatikus számát a következőképpen definiálja: 18. Definíció. [Mc Cabe-féle ciklomatikus szám] A G = (v, e) vezérlési gráf V (G) ciklomatikus száma V (G) = e v + 2p, ahol p a gráf komponenseinek a számát jelöli, ami megegyezik az erősen összefüggő gráfban található lineárisan összefüggő körök számával [5]. A mértéket a?? fejezetben kiegészítjük néhány új tulajdonsággal. 19. Definíció. [M ccabe] A M ccabe ciklomatikus szám a modulok függvényein mért értéke megegyezik Az f i függvény ágait (overload változatait) jelölje fc(f i ), és az ágakban található if, valamint case kifejezések ágait jelölje if(f i ), és ca(f i ). Ekkor a McCabe ciklomatikus szám függvényekre mért eredménye MCB(f i ) = fc(f i ) + case_cl(f i ) + if_cl(f i ). A mértéket alkalmazhatjuk függvények egy csoportjára MCB(f 1,..., f k ) = MCB(f j ). Az m i M modul függvényein mért eredmény megegyezik a modul összes függvényén mért értékek összegével: j=1 MCB(m i ) = MCB(F (m i )) Az összes modulra mért érték pedig a modulokra mért értékek összege: MCB(M) = m M MCB(F (m)) 12

13 8. Megjegyzés. A mért modulban meghívott függvények akárhány kimenettel (visszatérési pont) rendelkeznek is, egy útvonal végének számítanak, ezért ezeket nem vesszük figyelembe. Függvényre irányuló hívások száma A calls_for_function mérték az adott függvényre történő hívások számát adja vissza. Ez a forrásszöveg jellemzése szempontjából nagyon fontos érték, mivel ez alapján lehet eldönteni, hogy egy függvény egy intef ace modul valamely számításokat végző függvénye, vagy egy library modul olyan segéd függvénye, amelyet más modulok használnak egy adott részfeladat elvégzésére. A kiszámítás módja hasonlít a modulra irányuló függvény hívások számának kiszámítására, de itt a modul egyetlen függvényét mérjük és a modulon belülről induló hívásokat is figyelembe vesszük. 20. Definíció. [calls_for_function] Valamely f i függvényre irányuló függvényhívások száma CF F (f i ) = C(F (M), f i ). A mérték alkalmazható függvények egy csoportjára CF F (f 1,..., f k ) = CF F (f j ). j=1 Függvényből kiinduló hívások száma A calls_from_function mérték az adott függvényből induló függvény hívások számát méri, vagyis azt, hogy a függvény hány másik függvényt hív meg. Amennyiben egy függvényt kétszer hív a mért függvény, a kapcsolatot egynek számoljuk, és a rekurzív hívásokat sem vesszük figyelembe. 21. Definíció. [calls_from_function] Valamely f i függvényből kiinduló függvényhívások száma CF MF (f i ) = C(f i, F (M)). A mérték alkalmazható függvények egy csoportjára. CF MF (f 1,..., f k ) = CF MF (f j ) j=1 Függvény kifejezések száma A number_of_funexpr mérték a modulban szereplő (function expression) függvény kifejezések számát adja vissza. A függvény kifejezés hívását nem, de a bevezetését (definíció) méri. A 4 forrásszövegben szereplő függvény kifejezések száma a látszat ellenére egy. A programok bonyolultsága mellett azok olvashatóságát, valamint továbbfejleszthetőségét is nagyban befolyásolja az alkalmazott függvény kifejezések, és (λ) függvények) száma mind a forráskód, mind a szintaxisfa tekintetében. 13

14 Függvény kifejezések F = fun(a) -> A + 1 end, 2. F(1), 3. F2 = fun a/1, ábra. Függvény kifejezések száma 9. Megjegyzés. A függvény kifejezések következő két formáját tudjuk detektálni a forráskódot reprezentáló szemantikus gráfban (az első forma a 4 forrásszövegben az első sorban elhelyezett, az F változóba kötött kifejezésnek, a második az F 2 változóba kötöttnek felel meg): fexp 1 : fun(p 1 1,..., p 1 n) when g 1 e 1 1,..., e 1 l 1 ;. (p m 1,..., p m n ) when g m e m 1,..., e m l m fexp 2 : fun m : g/n or fun g/n Ahol a függvény kifejezéseket a fun nyelvi elem vezeti be, a p i j P paraméterek, g i G őrfeltételek, és e i E kifejezések. 22. Definíció. [number_of_funexpr] Jelölje az f i függvény által tartalmazott függvény kifejezéseket F exp (f i ) = {f exp 1,..., fn exp }, mely halmaz nem tartalmazza az f i függvény által hívott más függvényekben található függvény kifejezéseket. Ez esetben a number_of_funexpr mérték NF E(f i ) = F exp (f i ). A mértéket alkalmazhatjuk több függvényre NF E(f 1,..., f k ) = NF E(f i ), és modulokra egyaránt. Az modulokra mért eredmény megegyezik a modulokban definiált függvényekre mért eredmények összegével i=1 NF E(m i ) = NF E(F (m i )) és az összes modulra mért érték azonos a modulokra mért értékek összegével NF E(M) = m M NF E(m). 14

15 Üzenetküldések száma A number_of_mess_pass mérték egy függvény esetén az abban található üzenetküldéseket megvalósító kódrészletek, modul esetén a modulban szereplő összes függvényben előforduló üzenetküldések számát méri. Az Erlang pl. támogatja az elosztottságot, és az elosztott programokban az adatcserét közös memória használata nélkül valósítja meg. A függvényekből induló, vagy másképpen a modulok közti szinkron, és asszinkron üzenetküldések száma ezért nagyban befolyásolhatja a mért program bonyolultságát. 10. Megjegyzés. A nyelvi primitíveket az üzenetküldés megvalósítására. Az üzenet küldése a! operátorral, az üzenetek fogadása a receive kifejezéssel történik. r 0 : e 1! e 2 r : receive p 1 when g 1 e 1 1,..., e 1 l 1 ;. p n when g n e n 1,..., e n l n after MS e n+1 1,..., e n+1 l n+1 end ahol az e 1! e 2 az e 1 kifejezés küldése az e 2 kifejezésben adott cél számára. Az szinkron üzenetküldéseknél a fogadó félnél az r az üzenet fogadását teszi lehetővé. A receive ágaiban a p i P minták, amelyekre az üzenetben kapott kifejezés illeszkedhet, a g i G hasonlóan a case ágainál látottakhoz őr feltételek, és e i j E kifejezések az ágakban. Az üzenet fogadásához tartozik egy olyan ág, amelyet az af ter kulcsszó vezet be, és ez alapértelmezett ágként akkor következik, ah az üzenet az előző ágakra nem illeszkedett, és az M S paraméterben megadott időkorlát letelt. A mérték az üzenetküldések számát méri, vagyis az e 1! e 2 alakú kifejezéseket a függvényben. 23. Definíció. [number_of_mess_pass] Az f i függvény tartalmazhat üzenetek küldését megvalósító, e 1! e 2 alakú kifejezéseket, ezeket jelölje S(f i )) = {s 1,..., s n }. Ekkor a number_of_mess_pass mérték eredménye a NOMP (f i ) = S(f i ) A mértéket alkalmazhatjuk függvények halmazára NOMP (f 1,..., f k ) = NOMP (f i ), és modulokra egyaránt. Az modulokra mért eredmény megegyezik a modulokban definiált függvényekre mért eredmények összegével i=1 NOMP (m i ) = NOMP (F (m i )) 15

16 , és az összes modulra mért érték azonos a modulokra mért értékek összegével NOMP (M) = m M NOMP (m). 11. Megjegyzés. Egy függvényre mérve gráfútvonalat specializálni kell a függvény nevéből, és paraméterszámából álló párral. Külső hívások száma Az external_calls a mérésben szereplő függvényre alkalmazott, de más modulokból érkező függvényhívások számát adja vissza úgy, hogy egy függvény felől érkező több hívás is csak egynek számít. Ez, és a következő három (internal_calls, internal_calls_from, external_calls_from) mérték is releváns, mikor a függvényeket modulokba próbáljuk sorolni, vagy klaszterezési feladatokat szeretnénk megoldani. 24. Definíció. [external_calls] Az f i függvényre irányuló, más modulokból érkező függvényhívások száma ECL(f i ) = C(F (M), f i ). Belső hívások száma A internal_calls a mérésben szereplő függvényekre alkalmazott, de a függvényeket tartalmazó modulból érkező függvényhívások számát adja vissza úgy, hogy egy függvény felől érkező több hívás is csak egynek számít. A mérték kiterjesztése a calls_for_function mértéknek úgy, hogy kizárólag a modulon belülről érkező hívásokat veszi figyelembe. A definíció, és a kiszámítás módja szinte teljesen megegyezik az internal_calls mértéknél tárgyaltakéval annyi különbséggel, hogy itt a hívó, és a hívott függvény moduljának meg kell egyeznie, vagyis mindkét függvény definícióját ugyanaz a modul tartalmazza. A mérték eredménye: ICL(f i ) = C(F (m i ), f i ), ahol m i M az f i függvényt tartalmazó modul. Modulon kívülre irányuló hívások Az external_calls_from a mérésben szereplő függvényből jövő de más modulokba irányuló függvényhívások számát adja vissza. A mérték a function_calls_out (lásd.: a 12. definícióban) mértéket specializálja ki úgy, hogy csak egy adott függvényből kiinduló, de annak moduljától különböző modulokba tartó hívások számát veszi figyelembe, vagyis nem a modulra, hanem annak egyetlen függvényére számolja ki az eredményt. 25. Definíció. [external_calls_from] Jelölje az M = M \ {m i } az összes, kivéve az f i függvényt tartalmazó modult. Ekkor az ECF (f i ) = C(f i, F (M )). Az eredmény kiszámításához a modul, majd a függvény csomópontokból indulva a f uncall éleken át megkapjuk az összes hívást végző függvény csomópontjainak listáját. Ennél a mértéknél azonban az útvonalat egy függvényre kell specializálni a függvény nevéből, valamint a paraméterszámából alkotott párral func, {name = name(f i ), arity = arity(f i )}, ahol az f i a mért függvény. A kapott listában meg kell keresnünk azokat az elemeket, amelyek az m i modulban 16

17 vannak definiálva. A kereséshez a {f unc, back} éleken haladva minden hívást végző függvényhez meg kell annak modulját, majd (f c, m j ) alakú párokat alkotni belőlük, ahol a párok első eleme a hívó függvény, a második annak modulja. A mért függvény modulja adott. A kapott párok listájából ki kell válogatni azokat, ahol a mért függvény modulja nem azonos a párban szereplővel. Modulon belülre irányuló hívások A internal_calls_from a mérésben szereplő függvényből kifelé tartó, a függvényt tartalmazó modulba irányuló függvényhívások számát adja vissza úgy, hogy egy függvény felől érkező több hívás is csak egynek számít. A mérték a function_calls_in (lásd.: a 11. definícióban) mértéket terjeszti ki úgy, hogy csak egy adott függvény felé tartó, de annak moduljától különböző modulokból jövő hívások számát veszi figyelembe, vagyis az útvonal kifejezést specializálja egy adott függvényre (nem a modulra, hanem annak egyetlen függvényére számolja ki az eredményt). 26. Definíció. [internal_calls_from] Jelölje az M = M \ {m i } az összes, kivéve az f i függvényt tartalmazó modult. Ekkor az ICF (f i ) = C(F (M ), f i ). Azonosító hossza A length_of_name mérésben szereplő azonosító (függvénynév) karakterekben mért hosszát adja, ami akkor lehet érdekes, ha a kódsorok, és ezáltal a programszöveg olvashatóságát próbáljuk mérni, és javítani. Megjegyzés. Az id i az f i F (M) függvényt azonosítja, és a hossza az id i -t alkotó jelek száma, vagyis LON(f i ) = id i A függvények nevéhez a szemantikus gráfban a modulokon keresztül juthatunk el. A függvényekről, ahogy minden n N gráf csomópontról le tudjuk kérdezni az adott típust jellemző attribútumok értékét. A függvényeket a névvel és a paraméterszámmal azonosíthatjuk, ezután meg tudjuk állapítani a név, vagyis az azonosító hosszát. Paraméterek száma A number_of_funpars a mérésben szereplő függvény formális paraméterlistájának az elemszámát (aritás) adja eredményül. A mérték kiszámításához az adott függvény paramétereinek a számát nem kell direkt módon megszámolni, elég csak megkeresni a függvény definícióját, amely tartalmazza az őt jellemző attribútumokat. A kapott listából ki kell választani a mérésre szánt függvényt, és megnézni az aritását. 12. Megjegyzés. A függvények definíciójában a p i P minták alkotják az adott függvény paraméterlistáját, és a nyelv szintaxisa alapján az f j függvény minden fi c függvény ága megegyező számú paraméterrel rendelkezik, és p i az f j függvény bármely ágának paraméterlistáját reprezentáló minta, akkor a mérték eredménye, vagyis NOF P (f j ) = p i. 17

18 Függvény összesített értéke A function_sum mérték a függvényre, vagy függvényekre jellemző komplexitási mértékekből számított érték. Az eredmény kiszámításához szükséges mértékek felsorolással megadhatóak. 27. Definíció. [f unctions_sum] Jelölje a RefactorErl bonyolultságot elemző algoritmusával mérhető, és ezek közül a a függvényekre alkalmazható bonyolultsági mértékek véges halmazát Me func = {me func 1, me func 2,..., me func n }, valamint legyen S Me func. Ekkor az F S(S, f i ) := me func (f i ) me func S az f i függvényt jellemző, és az S-ben megadott mértékek összesített értéke. Hivatkozások [1] McCabe T. J. A Complexity Measure, IEE Trans. Software Engineering, SE-2(4), pp (1976) [2] Fóthi Á., Nyéki-Gaizler J. On The Complexity of Object-Oriented Programs in Proc. of the 3rd Symp. on Programming Languages and Software Tools Kaariku, Estonia, (1993) [3] Fóthi Á., Nyéki-Gaizler J., Porkoláb Z. The Structured Complexity of Object Oriented Programs Computers and Mathematics with applications, (2002) [4] Zoltán Porkoláb, Ádám Sipos, Norbert Pataki, Structural Complexity Metrics on SDL Programs. Computer Science, CSCS 2006, Volume of extended abstracts, (2006) [5] Zoltán Porkoláb Programok Strukturális Bonyolultsági Méröszámai. PhD thesis Dr Töke Pál, ELTE Hungary, (2002) [6] Tamás Kozsik, Zoltán Csörnyei, Zoltán Horváth, Roland Király, Róbert Kitlei, László Lövei, Tamás Nagy, Melinda Tóth, Anikó Víg Use Cases for Refactoring in Erlang. In Central European Functional Programming School, volume 5161/2008, Lecture Notes in Computer Science, pages , (2008) [7] Piwowarsky, P. A Nesting Level Complexity Measure. ACM Singplan Notices 17(9) pp (1982) [8] Lövei, L., Hoch, C., Köllö, H., Nagy, T., Nagyné-Víg, A., Horpácsi, D., Kitlei, R., and Király, R.: Refactoring module structure in.:proceedings of the 7th ACM SIGPLAN workshop on ERLANG Columbia, Canada, (2008) [9] Horváth, Z.: Elosztott funkcionális programok helyessége (Verification of Distributed Functional Programs) Project report, OTKA. (2006) 18

19 [10] R. Kitlei, L. Lövei, M Tóth, Z. Horváth, T. Kozsik, T. Kozsik, R. Király, I. Bozó, Cs. Hoch, D. Horpácsi.: Automated Syntax Manipulation in RefactorErl. 14th International Erlang/OTP User Conference. Stockholm, (2008) [11] The IBM United States 19