Ինտերպրետատոր

Վիքիպեդիայից՝ ազատ հանրագիտարանից

Ինտերպրետատորը ծրագիր է, որը ուղղակիորեն կատարում է, ծրագրավորման կամ սկրիպտավորման լեզուներով գրված հրամաններ, առանց դրանք նախապես կոմպիլյացնոլով մեքենայական լեզվի ծրագրի։ ինտերպրետատորը ծրագրի կատարման համար հիմանակնաում օգտագործում է հետևյալ ստրատեգիաներից մեկը՝

  1. վերլուծել (անգլ.՝ parse) սկզբնական կոդը և ուղղակիորեն կատարել։
  2. թարգմանել սկզբնական կոդը, ինչ որ միջանկյալ տեսքի և իրականացնել այն։
  3. Հստակ իրականացնել պահպանված նախակոմպիլյացված(անգլ.՝ precompiled) կոդը՝ կոմպիլյատորի կողմից կազմված, որը հանդիսանում է ինտերպրետատորի համակարգի մի մաս։

Սկզբնական ծրագրերը կոմպիլյացվում են նախապես և մեքենայում պահվում որպես անկախ կոդ, որը հետո կապվում է կատարման ժամանակ և իրականացվում ինտերպրետատորի և/կամ կոմպիլյատորի կողմից(անգլ.՝ JIT կոմպիլյացիայի համակարգի համար)։

Չնայած ինտերպրետացիան և կոմպիլյացիան համարվում են երկու հիմանական միջոց ծրագրավորման լեզուների իրականցման համար, դրանք չեն հակասում միմյանց, որովհետև ինտերպրետացվող համակարգերի մեծ մասը կատարում է նաև թարգմանչական աշխատանք, ինչպես կոմպիլյատորը։ "Ինտերպրետացվող լեզու" կամ "կոմպիլյացվող լեզու" տերմինները նշանակում են որ տվյալ լեզվի իրականցումը տեղի է ունենում ինտերպրետատորի կամ կոմպիլյատորի միջոցով՝ համապատասխանաբար։

Կոմպիլյատորների և ինտերպրետատորների համեմատումը[խմբագրել | խմբագրել կոդը]

Կապերի խմբագրիչի գործընթացը։

Բարձր մակարդակի լեզուներով գրված ծրագրերը, կամ ուղղակիորեն իրականցվում են ինտերպրետատորի ինչ-որ մի տեսակով, կամ կոմպիլյատորի կողմից ձևափոխվում են մեքենայական կոդի՝ պրոցեսորի համար, որպեսզի այն կատարի։

Չնայած կոմպիլյատորների հիմանկան արդյունքը հարդվերի կողմից գործարկվող մեքենայական կոդն է, դրանց արդյունքը հաճախ կարող է ընդունել միջանկյալ տեսք՝ օբյեկտային կոդ(անգլ.՝ object code ) անվանմամբ։ Կոմպիլյացվող ծրագիրը սովորաբար օգտագործում է կառուցվող բլոկներ (ֆունկցիաներ) գրադարանում պահված այդպիսի օբյեկտային կոդի մոդուլներ. Կապերի խմբագրիչը (անգլ.՝ linker )օգտագործում է գրադարանային ֆայլերը օբյեկտային ֆայլերի հետ միավորելու համար մեկ գործարկվող (անգլ.՝ executable ) ֆայլում։

Երկուսն էլ՝ կոմպիլյատորները և ինտերպրետատորները հիմնականում սկզբնական կոդը վերածում են թոքենների (անգլ.՝ token), երկուսն էլ կարող են գեներացնել վերլուծության ծառ(անգլ.՝ parse tree), և երկուսն էլ կարող են գեներացնել անմիջական հրահանգներ (ստեկային մեքենայի համար, կամ այլ միջոցներով)։ Հիմնական տարբերությունը այն է, որ կոմպիլյացվող համակարգերը, այդ թվում լինկերը, գեներացնում են ակախ գործող մեքենայական կոդի ծրագիր, մինչ դեռ ինտերպրետացվող համակարգերը դրա փոխարեն իրականացնում են գործողություններ նկարագրված բարձր մակարդակի լեզուներով։

Կոմպիլյացում և ինտերպրետացում

Կոմպիլյատորը փոխակերպում է միանգամից ամբողջ սկզբնական կոդը։ Արդյունքը ստացվում է մեկ կամ մի քանի օբյեկտային կոդի ֆայլեր։ Իտերպրետատորը նույնպես փոխակերպում է սկզբանական կոդը, սակայն տող առ տող։ Երբ առաջին տողը արդեն փոխակերպված է, այն միանգամից կատարվում է։

Մեկ անգամ կոմպիլյացնել և կատարել ցանկացած ժամանակ։ Կոմպիլյացվող ծրագիրերն ամեն անգամ չեն կոմպիլյացվում։ Ինտերպրետացվող ծրագրերը ինտերպրետացվում են տող առ տող ամեն անգամ, երբ դրանք կատարում են։

Կոմպիլյաորը չի թույլատրում գործարկել ծրագիրը, քանի դեռ այն լիովին անսխալ է։ Ինտերպրետատորը կատարում է ծրագիրը առաջին տողից սկսած և դադարում է միայն այն դեպքում, երբ հանդիպում է սխալ։

Մշակման ցիկլ[խմբագրել | խմբագրել կոդը]

Ծրագրային ապահովման մշակման ցիկլում, ծրագրավորողները սկզբնկան կոդում հաճախակի փոփոխություններ են կատարում։ Կոմպիլյատորի օգտագործման դեպքում, ամեն անգամ երբ սկզբնական կոդը փոխվում է, դրանք պետք է սպասեն կոմպիլյատորին, որպիսի թարգմանի փոխված սկզբնական ֆայելրը (անգլ.՝ source file), և կապի բոլոր երկուական կոդերի ֆայլերը իրար, հետո ծրագրը կարող է կատարվել։ Ինչքան ծրագիրը մեծ է, այդքան երկար պետք է սպասել։ Ինտերպրետատորի օգտագործման դեպքում ծրագրավորողը սպասում է ավելի քիչ, քանի որ ինտերպրետատորը կոդը թարգմանում է ներկայացնելով այն միջանկյալ տեսքով(կամ ամբողջը չի թարգմանում)։ Հետևությունները դառնում է ակնհայտ, սկզբանակն կոդը պահելուց (անգլ.՝ saving) և ծրագիրը բեռնելուց(անգլ.՝ reloading) հետո։

Բաշխման սկզբունք[խմբագրել | խմբագրել կոդը]

Скриншот 2015-12-02 21.52.29.png

Կոմպիլյատորը սկզբնական կոդը փոխակերպում է բինար ինստրուկցիաների, հատուկ պրոցեսսորի համար, դարձնելով այն ավելի քիչ դյուրակիր(անգլ.՝ portable)։ Այդ փոխակերպումը տեղի է ունենում միայն մեկ անգամ և դրանից հետո նույն բինար ինստրուկցիաները տեղաբաշխում են օգտագործողի մեքենայում, որտեղ այն կարողանում է կատարվել առանց հետգա թարգմանությունների։ Կրոսս կոմպիլյատորները կարողանում են գեներացնել բինար կոդ օգտագործողի մեքենայի համար, անգամ եթե այն ունի այլ պրոցոսսոր քան մեքենան, որտեղ կոդը կոմպիլյացվում է։

Ինտերպրետացվող ծրագրերը կարող են բաշխվել սկզբնական կոդի տեսքով։ Այն պետք է թարգմանված լինի յուրաքանչյուր վերջնական մեքենայում, որը շատ ժամանակ է տևում, բայց ծրագիրը տեղաբաշխում է անկախ մեքենայի ճարտարապետությունից։ Այնուամենայնիվ, ինտերպրետացվող սկզբանկան կոդերի տեղափոխումը կախված է ելքային մեքենայից (անգլ.՝ target machine) իրապես ունենալով համապատասխան ինտերպրտատոր։

Էֆեկտիվություն[խմբագրել | խմբագրել կոդը]

Հիմանականում ինտերպրետատորի թերությունը հանդիսանում է այն, որ ինտերպրետատորը ծրագիրը կատարում է դանդաղ, քան եթե այն կոմպիլյացված լիներ։ Արագության փոփոխությունը կարող է լինել մեծ կամ փոքր։ Ինտերպրետատորի ներքևի ծրագրը աշխատացնելու համար, այն հիմանկանում զբաղեցնում է երկար ժամանակ, քան կոմպիլյացված ծրագրն աշխատացնելը, բայց դա ինտերպրետացնելու համար այն կարող է զբաղեցնել քիչ ժամանակ, քան դա կոմպյացնելու և աշխատացնելու ընդհանուր ժամանակը։ Սա հատկապես կարևոր է, երբ նախատիպավորվում և տեստավորվում է կոդը, երբ խմբագիր-ինտերպրետատոր-դեբագ ցիկլը(անգլ.՝ edit-interpret-debug ) հաճախ կարող է լինել շատ ավելի կարճ քան խմբագիր-կոմպիլյացիա-կատարում-դեբագ (անգլ.՝ edit-compile-run-debug ) ցիկլը։

Կոդի ինտերպրետացումը կատարվում է ավելի դանդաղ է, քան կոմպիլյացվող կոդի կատարումը, քանի որ ծրագրում ինտերպրետատորը պետք է վերլուծի յուրաքանչյուր հրաման, ամեն անգամ երբ այն կատարվում է և հետո կարի անհրաժեշտ գործողություններ, մինչդեռ կոմիլյացվող կոդը ուղղակի կատարում է գործողություններ, ֆիքսված կոնտեքստում՝ կոմպիլյատորի կողմից սահմանված։ Դա կատարման ժամանակի վերուծությունն է։ Ինտերպրետատորում փոփոխականների հասանելությունը ևս դանդաղ է, քանի որ պահպանման տեղերում իդենտիֆիկատորների մափփինգը(անգլ.՝  mapping) պետք է անել հաճախակի կատարման ժամանակ, այլ ոչ թե կոմպիլյացիայի ժամանակ։

Մշակման արագության(երբ օգտագործում են ինտերպրետատոր) և կատարման արագության (երբ օգտագործում են կոմպիլյատորներ) միջև գոյություն ունեն տարբեր կոմպրոմիսներ։ Որոշ համակարգեր (օրինակ որոշ լիսպեր)թույլատրում են ինտերպրետացնել և կոմպիլյացնել կոդը կանչելով միմյանց և բաժանելով փոփոխականները։ Շատ Ինտերպրետատորներ սկզբնական կոդը չեն կատարում, ինչպես արժե, բայց այն փախակերպում են ինչ-որ ավելի կոմպակտ ներքին տեսքի։ Շատ հիմանական ինտերպրտատորներ բանալի բառերը փոխարինում են մի բայթ նիշերի (անգլ.՝ byte tokens ), որոնք կարող են օգտագործվել անցման աղյուսակներում (անգլ.՝ jump table) ինստրուկցիաների որոնման համար։ Որոշ ինտերպրետատորներ, ձգտում են ավելի բարձր մակարդակի ծրագրերի խտացման՝ օգտագործելով բիթ-կողմնորոշված(այլ ոչ թե բայթ-կողմնորոշված ) ծրագրերի հիշողության ստրուկրուրաներ, որտեղ նշանների հրամանները հնարավոր է զբաղեցնեն 5 բիթ, անվանապես "16-bit" հաստատնները պահվում են փոփոխական-երկարության կոդում (անգլ.՝ variable-length code , այն կոդ է, որը ցուցադրում է սկզբնական սիմվոլները փոփոխականի թվերի բիթերով ) պահանջելով 3, 6, 10, կամ 18 բիթ և օպերանդի հասցեն ներառում է <բիթ օֆսեթ> (անգլ.՝ bit offset

Ինտերպրետատորը կարող է օգտագործել նույն լեքսիական անալիզատորը և շարահյուսական վելուծություն, ինչպես կոմպիլյատորը և հետո ինտերպրետացնում է արդյուքը աբստրակտ շարահյուսության ծառի տեսքով(անգլ.՝ abstract syntax tree

Կոմպիլյացում և ինտերպրետացում

Ռեգրեսիա[խմբագրել | խմբագրել կոդը]

Ծրագրի կատարման համար ինտերպրետացիան չի կարող օգտագործվել միակ մեթոդ՝ թեև ինտերպրետատորը կարող է ինքն իրեն ինտերպրետացնել և այլն, ծրագրի անմիջական կատարման համր անհրաժեշտ է ստեկի ներքևի ինչ որ հատված, ինչպես պրոցեսսորը կարող է կատարել մեքենայկան կոդը ։

Վարիացիաներ[խմբագրել | խմբագրել կոդը]

Բայթկոդ ինտերպրետատորներ[խմբագրել | խմբագրել կոդը]

    1rightarrow.png Հիմնական հոդված՝ Բայթկոդ


Ինտերպրետացիայի և կոմպիլյացիայի միջև կան հնարավորությունների ամբողջ սպեկտոր, կախված կատարված վերլուծությունների քանակից՝ մինչև ծրագրի կատարումը։ Օրինակ Emacs Lisp-ը կոմպիլյացնում է բայթկոդը, որը չափազանց խտացված է (անգլ.՝ compressed ) և օպտիմիզացիան ներկայացնում է Լիսպի սկզբանական, բայց ոչ մեքքենայական կոդ։ Այդ <կոմպիլյացված> կոդը հետո ինտերպրետացվում է բայթկոդ ինտերպրետատորով։ Այս դեպքում կոմպիլյացված կոդը մեքենայական կոդ է վիրտուալ մեքենայի համար, որը իրականցվում ոչ թե հարդվերում, այլ ինտերպրետատորի բայթկոդում։ Նույն մոտեցումը օգտագործվում է Forth կոդի դեպքում օգտգերծելով Open Firmware համակարգում՝ սկազբանկան լեզուն կոմպլյացվում է <F code>-ի (բայթկոդ), որը հետո ինտերպրետացվում է վիրտուալ մեքենայում։

Աբստրակտ շարահյուսության ծառ Ինտերպրատատորներ[խմբագրել | խմբագրել կոդը]

Ինտերպրետացիայի և կոմպիլյացիայի միջև, այլ մոտոցում է, սկզբնական կոդի փոխակերպումը օպտիմալցված աբստրակտ շարահյուսության ծառի, կոմպիլյացնելով ծրագիրը այդ ծառի կառուցվածքին, կամ օգտագործում է այն դինամիկ գեներացնելով սեփական կոդ(անգլ.՝ native code կամ մեքենայական կոդ) ։ Այս մոտեցմամբ նախադասության շարահյուսական վերլուծությունը(անգլ.՝ parse ) կատարվում է միայն մեկ անգամ։ JIT-կոմպիլյյատերների համար աբստրակտ շարահյուսության ծառը (անգլ.՝ AST ) հանդիսանում է ավելի լավ միջանկյալ ձևաչափ, քան բայթկոդը։ Բացի այդ Ծրագրի կատարման ժամանակ այդ համակարգը ավելի լավ վերլուծություն է կատարում։

Սակայն, ինտերպրետատորների համար աբստրակտ շարահյուսության ծառը (անգլ.՝ AST ) դառնում է պատճառ ավելի շատ վերադիր ծախսերի (անգլ.՝ overhead ), քան բայթկոդ ինտերպրետատորի դեպքում։

JIT կոմպիլյացիան (Just-in-time compilation)[խմբագրել | խմբագրել կոդը]

.NET կոպիլյատորով սկզբնական կոդը կոմպիլայցվում է ՛՛exe՛՛-ի կամ ՛՛dll՛՛-ի
    1rightarrow.png Հիմնական հոդված՝ JIT կոմպիլյացիան


JIT կոմպիլյացիան տեխնալոգիա է, որը բարձրացնում է ծրագրային համակարգերի արդյունավետությունը, օգտագործելով բայթկոդ, կոմպիլյացնում է այն մեքենայական կոդի կամ այլ ձևաչափի, ծրագրի կատարման ժամանակ։ Դա տալիս է էֆեկտիվություն սեփական կոդը աշխատեցնելիս, գործարկաման ժամանակի հաշվին և ավելացնում է հիշողության օգտագործումը երբ բայթկոդը կամ աբստրակտ շարահյուսության ծառը սկզբում կոմպիլյացվում են։ Ադապտիվ օպտիմիզացիան լրացուցիչ մեթոդ է, որում ինտերպրետատորը ուրվագծում է կատարվող ծրագիրը և կոմպիլյացնում է սեփական կոդում, առավել հաճախակի կատարվող մասերը։ Երկու մեթոդներն էլ հին են, հայտնվել են այնպիսի լեզուներում ինչպիսին է ՝ Smalltalk-ը 1980 թ․-ին։

Self-ինտերպրետատոր (Self-interpreter)[խմբագրել | խմբագրել կոդը]

Self-ինտերպրետատորը ծրագրավորման լեզվի ինտերպրետատոր է, գրված ծրագրավորման լեզվով, որը կարող է ինտերպրետացնել ինքն իրեն, օրինակ BASIC ինտերպրետատորը գրված BASIC-ով։

Եթե լեզվի համար գոյություն չունի կոմպիլյատոր պետք է ինտերպրետացնել, Self-ինտերպրետատորի ստեղծումը պահանջում է լեզվի իրականացում բազային լեզվում(անգլ.՝ host language ), այն կարող է լինել ցանկացած ծրագրավորման լեզու կամ ասսեմբլեր։ Ունենալով առաջին ինտերպրետատորը ինչպիսին դա է, համակարգը բուտստրապպվում է(անգլ.՝ bootstrapping , ծրագրավորման լեզվի կոմպիլյատորի ստեղծման մեթոդ է, երբ կոմպիլյատորի կոդի զգալի մասը ստեղծվում է ելքային լեզվով (անգլ.՝ Target language ))

Համակարգչային լեզվի սահմանումը, որպես կանոն իրականցվում է աբստրակտ մեքենայով (անգլ.՝ operational semantics ) կամ մաթեմատիկակն ֆունկցիաներով(անգլ.՝ denotational semantics)։ Լեզուները կարող են սահմնավել ինտերպրետատորով, որում բազային լեզվի (անգլ.՝ host language ) սեմանտիկան տրված է։ Self-ինտերպրետատորվ սահմանված լեզուները հիմնավորված չեն (չեն կարող սահմանել լեզուներ), բայց Self-ինտերպրետատորը ընթերցողին ներկայացնում է լեզվի արտայհայտչությունը և էլեգանտությունը։ Դա նաև թույլ է տալիս թարգմանչին ինտերպրետացնել իր սկզբնական կոդը, առաջին քայլը ուղվելով ինտերպրետացիայի արտացոլմանը։ Կարևոր ասպեկտ է Self-ինտերպրետատորի իրականացումը՝ ինտերպրետացվող լեզվի առանձնահատկությունը հանդիսանում է արդյո՞ք նույն առանձնահատկություն՝ իրականցվող ինտերպրետատորի բազային լեզվում։

Հավելվածներ[խմբագրել | խմբագրել կոդը]

  • Ինտերպրետատորները հիմանակնում օգտագործում են կատարելու համար հրամանային լեզուներ, և glue լեզուներ, քանի որ յուրաքանչյուր օպերատոր կատարվում է հրամանային լեզվում, դա հիմանկանում կանչում է համալիր ենթածրագիր, այնպիսին ինչպիսին է խմբագիրը ( անգլ.՝ editor) կամ կոմպիլյատորը։
  • Ինքնաձևափոխվող կոդը ( անգլ.՝ Self-modifying code ) կարող է հեշտությամբ իրականցվել ինտերպրետացվող լեզուներում։ Դա վերաբերվում է Լիսպի ինտերպրետացիային և արհեստական բանականության հետազոտմանը։
  • Վիրտուալիզացիա( անգլ.՝ VirtualizationՎիրտուալիզացիան վերաբերվում է ինչ-որ բանի վիրտուալ տարբերակի ստեղծմանը, ներառած վիրտուալ հարդվերի պլատֆորմներ, օպերացիան համակարգեր, հիշող սարքեր, համակարգչային ցանցի ռեսուրսներ։։Մեքենայական կոդը նախատեսված մեկ հարդվերի ճարտարապետության համար, կարող է աշխատել մեկ ուրշներում, օգտագործոլով վիրտուալ մեքենա։
  • Ավազաման ( անգլ.՝ SandboxingԱվազամանը համակարգչային անվտանգությունում հատուկ մշակված միջոց է, համակարգչային ծրագրերի անվտանգ կատարման համար։։ Ինտերպրեատատորը կամ վիրտուալ մեքնենան իրականում ստիված չեն կատարել սկզբանական կոդի բոլոր հրամանները, դա մշակվում է։ Մասնավորապես, այն կարող է հրաժարվել կարարել կոդը, որը խախտում է որևէ ապահովության սահմանները։

Հղումներ[խմբագրել | խմբագրել կոդը]