Ծրագրի ստեղծումն ու ներքին կառուցվածքը

Ինչ է ծրագիրը, ինչպես է այն աշխատում

Ծրագրի օրինակ է Windows օպերացիոն համակարգի օգտագործողներին քաջ հայտնի տեքստային խմբագիրը՝ Notepad֊ը։ Հետաքրքիր է, թե ինչ կա այդ մեկ ֆայլի մեջ, որը հնարավորություն է տալիս օգտագործողին կատարել գործողություններ, օրինակ՝ տեքստ հավաքել, կամ փոխել տեքստի տառատեսակը, պահպանել տեքստը որպես տեքստային ֆայլ և այլն։ Բնականաբար, եթե մեզ անհրաժեշտ լինի ստեղծել նմանատիպ ծրագիր, կօգտվենք մեր սիրելի ծրագրավորման լեզվից, կգրենք անհրաժեշտ կոդը և կոմպիլյատորի միջոցով կթարգմանենք մեր գրած կոդը՝ մեքենայական կոդի։ Վերջինս հասկանալի է համակարգչին, ավելի ստույգ՝ օպերացիոն համակարգին։ Ի վերջո, եթե համակարգչում տեղակայված օպերացիոն համակարգ չկա, ապա ծրագիրն էլ համապատասխանաբար չի աշխատի։ Հեշտ է ստուգել, պարզապես համակարգչից հեռացրեք Windows ՕՀ֊ն ու փորձեք աշխատեցնել Notepad֊ը։ Դա կստացվի անել միայն Չակ Նորիսին։

Այսպես, ունենք հետևյալ նկատառումները՝

1. Ծրագիրը ֆայլ է։ Այո, պարտադիր չէ ֆայլ անվանել միայն տեքստային (.txt ընդլայնումով) կամ .mp3 ընդլայնումով ֆայլերին, ծրագիրը, որին այլ կերպ անվանում են կատարվող ֆայլ է (executable file , կամ պարզապես executable), որն ունի տարբերակող ընդլայնում՝ .exe:
2. Ծրագրի կատարման համար անհրաժեշտ է օպերացիոն համակարգ, մեր օրինակում` Notepad֊ը կատարվում է Windows ՕՀ֊ում։ Ստացվում է, ծրագրի կատարման համար պատասխանատու է մեկ այլ, շատ մեծ ծրագիր՝ օպերացիոն համակարգ։
3. Ծրագրավորման լեզվի հիմունքներից մեզ հայտնի է, որ համակարգիչը հասկանում է միայն այսպես կոչված մեքենայական կոդ։ Ստացվում է ծրագրավորման լեզվով գրված կոդը (որն իրենից ընդամենը տեքստ է ներկայացնում) պետք է թարգմանել այդ մեքենայական կոդի , որպեսզի այն դառնա կատարվող ֆայլ՝ executable file:

Մեքենայական կոդի տակ շատ հաճախ հասկանում ենք “0֊ների ու 1-երի հաջորդականություն”։ Դե, վերջին հաշվով, գիտենք որ համակարգչին հասկանալի է միայն 0 ու 1, լարում կա, լարում չկա, շղթայի բանալին փակ է, շղթայի բանալին բաց է, լամպը վառվում է, լամպը չի վառվում․․․ Մեքենայական կոդի նման սահմանումը սպառիչ չէ, 0 ու 1, միայն ֆիլմերում են օգտագործում “զրոներ ու մեկեր” ճիշտ պատասխանից խուսափելու համար, իսկ մեզ իսկապես հետաքրքիր է, ինչ է մեքենայական կոդը, միգուցե՞ 2֊ների ու 7֊երի հաջորդականություն։

Մեքենայական կոդը անմիջապես պրոցեսորի (CPU, Central Processing Unit) կողմից կատարվող ինստրուկցիաների բազմությունն է (instruction set)։ Առանցքայինը այստեղ instruction set֊ն է, որը համակարգչի ծրագրերի ու ապարատային մասի միջև հաստատող կապն է։ Instruction set ֊ով են սահմանվում այն ինստրուկցիաները, որոնք ի զորու է կատարել մեքենան։

Տվյալ դեպքում՝ պրոցեսորը, սահմանում է ինստրուկցիաների բազմություն, որոնք “հասկանում” է ու կարող է կատարել։ Ստացվում է, առայժմ չկենտրոնանալով պրոցեսորի ինստրուկցիաների բազմության վրա, որ պրոցեսորի կողմից սահմանված լեզուն՝ ինստրուկցիաների բազմությունը, ավելի ստույգ՝ այդ բազմության հիման վրա ինստրուկցիաների հաջորդականությունը գեներացվում է կոմպիլյատորի կողմից։

Հատկանշական է, որ մեքենայական կոդ կանվանենք թվային մեքենայական կոդին, այսինքն ոչ ասեմբլերական կոդին։ Հետևյալ կոդի հատվածը՝

mov ah, 2ch
int 21h
mov dl, ch
add dl, 48

մեքենայական կոդ չէ, այլ (առաջին հայացքից), ասեմբլերական կոդ է, որն իր հերթին թարգմանվում է էլ ավելի ցածր մակարդակի “տեսքի”, մինչև գեներացվի պրոցեսորին հասկանալի կոդ։ Ասեմբլերի կոդը առաջին քայլն էր դեպի բարձր մակարդակ, որը հնարավորություն տվեց ծրագրավորողին զգալ իրեն “հասարակ մահկանացու”։ Մինչ այդ, նրանք ստիպված էին ձեռքով հավաքել մեքենայական կոդը “տումբլերների” միջոցով, երբ համակարգիչները “դինոզավրեր” էին հիշեցնում։ Քարե դարի ծրագրավորողների աշխատանքը բարդ է եղել, հաճախ նրանք ասեմբլերով գրել են ծրագրերը թղթի վրա, այնուհետև հերթով, ձեռքով ինստրուկցիաները թարգմանել մեքենայական կոդի, որն արդյունքում մուտքագրել են համակարգիչ որպես տեքստային ֆայլ կամ անմիջապես աշխատեցրել են՝ օգտվելով “տումբլերներից”։ Դաժան զբաղմունք է, բայց մեր առջև այժմ դրված է խնդիր, այն է՝ հասկանալ, թե ինչ է ծրագիրը։ Մեր վերջին դատողությունների արդյունքում հանգեցինք նրան, որ ծրագիրը, կամ կատարվող ֆայլը, ներկայացնում է տեքստային ֆայլ, որը պարունակում է մեքենայական կոդ։

Փորձենք մոտենալ հակառակ կողմից, հասկանանք, թե ինչպես է աշխատում պրոցեսորը, օրինակ երբ գումարում է երկու թիվ, ին՞չ տեսքի կոդ պետք է փոխանցել պրոցեսորին, որպեսզի նա արդյունքում վերադարձնի երկու թվերի գումար։ Իհարկե պարզագույն օրինակ է, “իրական կյանքում” ձեր համակարգչի պրոցեսորը արդեն իսկ հազարավոր ինստրուկցիաներ կատարեց, մինչ դուք վերջացրեցիք այս նախադասությունը։ Ինչպե՞ս է հաջողվում մետաղի կտորի ու էլեկտրականության միջոցով ստանալ այսքան փոքր ու բարդ համակարգ, ինչպիսին է պրոցեսորը։

Անիմաստ է խորանալ պրոցեսորների ստեղծման տեխնոլոգիայի մեջ, թաթախվել նանոմետրերի ու կրեմնիումի մեջ, քանի֊որ ձեռքի տակ չունենք պրոցեսորների պատրաստման լաբորատորիա, իսկ Intel ընկերությունը մեզ չի պատկանում, մենք կփորձենք մրցել Intel֊ի հետ և կստեղծենք մեր սեփական պրոցեսորը։

Պրոցեսորը գործողություններ է կատարում (processing բառից), պարզագույն գործողությունը գումարումն է, անշուշտ, գումարման միջոցով հնարավոր է ստանալ նաև հանումը, բավական է թվին գումարել բացասական հանելին․

4 - 6 = 4 + (-6)

Հնարավոր է ստանալ նաև բազմապատկումը․

4 * 5 = 4 + 4 + 4 + 4 + 4 = 5 + 5 + 5 + 5

Եվ, վերջապես, բաժանումը կարելի է ներկայացնել հանումով՝ հաշվելով հանումների քանակը․

20 / 4 = 5

20 - 4 - 4 - 4 - 4 - 4 = 0 (քանի՞ անգամ հանեցինք 4)

կամ ավելի պարզ․ 20 / 4 = 20 * 1/4 (եթե իհարկե ունենք 1/4 ստանալու հեշտ եղանակ, հակառակ դեպքում ընդհանրապես “ավելի պարզ” չէ)։

Մեր առաջին քայլը կլինի ստեղծել պրոցեսոր, ավելի ստույգ՝ սարք, որին մենք հպարտորեն կանվանենք պրոցեսոր, որը կկատարի երկու թվերի գումարում։ Թվերը կներկայացվեն մեր առօրյայում ամենաշատ օգտագործվող հաշվարկման համակարգով՝ երկուականով (այսուհետ ձեր առօրյա հաշվարկման համակարգը կլինի ոչ թե տասականը, այլ՝ երկուականը)։ Եթե հնարավորություն ունենանք ստեղծել սարք, որը կկատարի թվերի գումարում, ապա մեր հաջորդ քայլերը կլինեն վերը նշված սկզբունքներով ադապտացնել սարքը թվերի հանում, բազմապատկում և բաժանում կատարելու համար։ Ունենալով թվաբանական այս չորս ֆունդամենտալ գործողությունները, կստեղծենք պրոցեսոր, կգրավենք աշխարհը և Intel֊ը կդառնա ընդամենը պատմություն։

Code Republic-ը ծրագրավորման գիտահետազոտական կենտրոն է, նմանատիպ հոդվածներ հրապարակվելու են պարբերաբար, հետևեք մեր պաշտոնական էջերին՝ վերջին թարմացումների համար։

Medium: Տեխնիկական Բլոգ և Ընդհանուր Հրապարակումներ

Facebook: https://www.facebook.com/coderepublicam

Instagram: https://instagram.com/coderepublic.am

LinkedIn: https://www.linkedin.com/company/code-republic-am/

YouTube: https://www.youtube.com/c/CodeRepublic

Սարքը ստեղծելու նկատառումներով, մենք կդիմենք վաստակավոր ծրագրավորող Չարլզ Փեթզոլդին (Charles Petzold), ով հեղինակել է կարևորագույն մի գիրք. Code: The hidden language of computer hardware and software:

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

Փեթզոլդն իր գրքում օգտվում է տրամաբանական տարրերի (logic gates) հետևյալ նշանակումներից.

Այս տարրերը կարելի է ու ցանկալի է պատկերացնել որպես էլեկտրական շղթաներ, որոնք մուտքին ստանում են լարում, իսկ ելքում տալիս են լարում կամ ընդհակառակը՝ չեն տալիս, կախված տարրի աշխատանքի բնույթից։ Այսինքն AND տարրի դեպքում a և b երկու մուտքերում էլ միաժամանակ պետք է լինի դրական մուտք, որպեսզի c ելքում լինի դրական արդյունք, ցանկացած այլ դեպքում c ելքում դրական արդյունքը բացակայում է (դրական մուտքի տակ նկատի ունենք 1 արժեք, ոչ դրական՝ 0 աժեք։ Եթե տրամաբանական տարրերը ծանոթ չեն, փորձեք ընթերցել վերոնշյալ գիրքը)։

Մեր պրոցեսորը պատրաստելու համար մեզ կպահանջվեն էլէկտրամագնիսական ռելեներ, մի բուռ բուլյան հանրահաշիվ և մի քանի գդալ տրամաբանական տարր՝ ըստ ճաշակի։

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

Վերևում պատկերված “սարքը” հպարտորեն կրում է Կիսագումարիչ անվանումը։ A և B մուտքերում սարքը ստանում է երկուական թվեր, արդյունքում տալով գումարը՝ S ելքում։ Ցավոք թե մուտքը, թե ելքը ի վիճակի են պահպանել միայն մեկ թիվ, իսկ թվերի գումարումից կարող է փոխանցում տեղի ունենալ, որն էլ արտահայտվում է սարքի C ելքում (S նշանակումը Sum (գումար) բառից, C֊ն՝ Carry (փոխանցում) բառից)։ Այս սարքը տրամաբանական տարրերով կարող է ներկայացվել այսպես․

Օգտագործվել են երկու տրամաբանական տարրեր՝ AND և XOR: Հիշենք այս տարրերի truth table-ները (աղյուսակները օգտագործվել են Վիկիպեդիայից)․

Ինչպես տեսնում ենք, XOR (որը Exclusive OR ֊ի կարճ անվանումն է, այսինքն՝ OR ֊ի բացառում) տրամաբանական տարրի ելքում ստացվում է 1 միայն ու միայն երբ երկու մուտքերում իրարից տարբեր արժեքներ են, իսկ AND ֊ի ելքում ստացվում է 1 միայն ու միայն երբ երկու մուտքերում 1 է։ Վերադառնալով կիսագումարիչի տրամաբանական սխեմային, դժվար չէ հասկանալ, որ իսկապես, այս սխեմայի միջոցով կարող ենք գումարել երկու երկուական համակարգի թվեր, օրինակ 1 + 0 = 1 երկուական համակարգում, նույնն է թե 0 + 1 = 1 , իսկ 1 + 1 = 10: Վերջին դեպքում ելքում ունենք երկու թվանշան, իսկ կիսագումարիչի S ելքը կարող է պահել մեկ թվանշան, հենց այստեղ է պարզ դառնում C փոխանցման ելքի դերը, ստացվում է 1 + 0 ֊ի դեպքում փոխանցում չկա, այսինքն S ֊ը հավասար է 1, իսկ C ֊ն 0, բայց 1 + 1 ֊ի դեպքում փոխանցում կա, S -ը հավասար է 0, իսկ C -n հավասար է 1: Ուշադրություն դարձրեք, երկուական համակարգում կան ընդամենը երկու նիշեր՝ 1 և 0, հետևաբար 1 + 0֊ն հավասար է 10 (մեկ֊զրո), ոչ թե տասի։ Ծրագրավորողները բաժանվում են 10 խմբի, նրանք ովքեր հասկանում են երկուական համակարգ և, նրանք, ովքեր չեն հասկանում։

Կիսագումարիչը աշխատանքի մեջ պատկերացնել կօգնի այս անիմացիան (աղբյուրը՝ Վիկիպեդիա)․

Մեզ հարկավոր է ունենալ իրական, ֆիզիկական սարք, որով կհամոզվենք որ տեսությունն աշխատում է։ Կիսագումարիչը դիտարկելով հասկացանք, որ բավական է ունենալ երկու տեսակի տրամաբանական տարր, այն է՝ XOR և AND : Ստեղծենք այդ տրամաբանական տարրերը էլեկտրական շղթաների միջոցով։ Մեզ կպահանջվի էլեկտրամագնիսական ռելե։ Օգտվենք Փեթզոլդի գրքից և տեղակայենք երկու էլեկտրամագնիսական ռելեներ նկարում պատկերված տեսքով, ապա կստանանք AND տրամաբանական տարրը, ուշադրություն դարձրեք, նկարում պատկերված են նույն շղթաների համախումբը, մի դեպքում բանալիները բաց, մի դեպքում՝ փակ․

Ձախ նկարում էլեկտրամագնիսական ռելեների բանալիները բաց են, հետևաբար լամպը չի վառվում, որպեսզի լամպը վառվի, պետք է միացնել միաժամանակ երկու ռելեները։ Ինչպես պատկերված է փակ բանալիներով աջ նկարում, լամպը վառվում է, քանի որ երկու ռելեների բանալիները փակ են, հետևաբար մագնիսները ձգում են ներքին բանալիները և լամպին հասնում է հոսանք։ Այս համակցված շղթան ներկայացնում է AND տրամաբանական փականը, որի դեպքում ելքում 1 է, եթե միաժամանակ երկու մուտքերում էլ 1 է։ Ստացվում է, հավաքելով նմանատիպ շղթա, մենք արդեն ի վիճակի ենք ստեղծել AND տրամաբանական տարրը, մեր կիսագումարիչի կարևոր բաղկացուցիչներից մեկը։

XOR֊ի կառուցվածքը համեմատաբար բարդ է, ստիպված ենք այն ներկայացնել այլ տամաբանական տարրերի կոմբինացիայով, այն է NAND , OR և AND ․

Ուշադրություն դարձրեք, NAND֊ի ելքը միանում է AND֊ի մուտքերից մեկին, իսկ AND֊ի մյուս մուտքին միանում է OR֊ի ելքը։

NAND (Not AND) տրամաբանական տարրը տարբերվում է AND֊ից դիմացը տեղակայված NOT ինվերտորով, որն ընդամենը “շրջում” է մուտքային արժեքը 1-ից 0, 0-ից 1։ NAND֊ի էլեկտրական շղթան կունենա հետևյալ կառուցվածքը․

Նկատենք, որ մագնիսները ձգելով ներքին բանալին անջատում են այն, այլ ոչ թե միացնում, ինչպես նախորդ շղթաներում։ Շղթայում հարկավոր է անջատել միաժամանակ երկու ներքին բանալիները, որպեսզի լամպը չվառվի, ցանկացած այլ դեպքում լամպը կվառվի, ինչն էլ հակասում է AND֊ի կանոններին, հետևաբար և կոչվում է NAND:

Վերջապես, OR֊ի շղթան կունենա այսպիսի տեսք․

Վերջինս, ցանկացած մուտքերից մեկում կամ երկու մուտքերում միաժամանակ ունենալով 1, ելքում տալիս է 1։

Այսպես, ունենալով AND, NAND և OR փականների շղթաների կառուցվածքները, կարող ենք պատկերել XOR֊ի շղթայի կառուցվածքը (հեղինակի ալարկոտության պատճառով շղթայի կառուցվածքի պատկերումը կրում է սիրողական բնույթ՝ այլմոլորակային լամպի հետ մեկտեղ)․

Նախորդ երկու պատկերներից դժվար է տեսնել (այո, դժվար է տեսնել), որ XOR֊ի ելքում 0 կստացվի եթե երկու մուտքերում արժեքները համընկնեն, այսինքն՝ միաժամանակ լինեն կամ 0, կամ 1։ Ընդհակառակը, XOR֊ի ելքում 1 կստացվի, եթե մուտքային արժեքները տարբերվեն իրարից։

Վերադառնանք կիսագումարիչի տրամաբանական սխեմային․

Արդեն մտովի կարող ենք պատկերացնել թե յուրաքանչյուր տրամաբանական տարր ինչ տեսքի ու քանակի էլեկտրական շղթաների համակցություն է ներկայացնում։ Բավական շատ, ինչ խոսք։ Ու այս ամենը ընդամենը խղճուկ “կիսա” գումարիչի համար, ստացվում է “լրիվ” գումարիչի համար կրկնակի անգամ շատ շղթա։ Ամեն դեպքում, ամփոփելով, կարող ենք վստահ ասել, որ ունենալով անհրաժեշտ քանակի ռելեներ, կարող ենք հպարտորեն կառուցել մեքենա, որը կարող է գումարել երկու երկուական թվեր։ Իսկ ինչ անել եթե երկուական թվերը մեկ նիշանոց չեն, այլ ասենք 2, կամ 4։ Մեր կիսագումարիչը հեշտությամբ կարող է կատարել այսպիսի գումարում․

1 + 1

1 + 0

0 + 1

0 + 0

Իսկ ինչպես կատարել այսպիսի գումարումներ

11 + 10

101 + 11

11110100 + 10011011

Մեր կիսագումարիչի թերությունն այն է, որ չենք կարող օգտագործել նախորդ գումարման արդյունքում առաջացած փոխանցումը։ Օրինակ, 11 + 10 գումարը հաշվելու համար կարող ենք կիսագումարիչով գումարել երկու թվերի առաջին սյունակները, այսինքն 1-ն ու 0֊ն, ուրախանալով, որ փոխանցում չկա, գումարել հաջորդ սյունակի թվերը, այն է՝ 1 և 1, վերջնական արդյունքում ստանալով՝ 101։ Իսկ ին՞չ անել, եթե հենց առաջին սյունակի գումարման արդյունքում առաջանա փոխանցում, օրինակ 11 + 11 գումարման համար, առաջին սյունակի 1 և 1 թվերը գումարելիս ստացվում է 0 գումար և 1 փոխանցում։ Հաջորդ սյունակին անցնելիս, չենք կարող կորցնել այդ փոխանցումը, ստացվում է, կիսագումարիչը պետք է 3րդ մուտքը ունենա, որ նախորդ գումարից առաջացած փոխանցումը կարողանանք գումարել նոր սյունակի երկու թվերի հետ։ Կիսագումարիչը ունի ընդամենը երկու մուտք։ Հենց սա էլ տալիս է կիսագումարիչին “կիսա”֊ություն։ Այո, մեր ապագա հաճախորդներին անհրաժեշտ է թվեր գումարող նորմալ սարք, դժվար կլինի մրցել Intel֊ի հետ, եթե վաճառենք 1-բիտանոց կիսագումարիչ։

Դիտարկենք հետևյալ տրամաբանական սխեման կազմված երկու կիսագումարիչներից և մեկ OR տարրից․

Մեջտեղում գտնվող կիսագումարիչը որպես A մուտք ստանում է նախորդ գումարից առաջացած փոխանցումը։ OR տարրը բավարար է վերջնական փոխանցում հաշվելու համար, քանի֊որ միաժամանակ երկու կիսագումարիչում փոխանցում չի լինում։ Ստացվում է, այս սխեմայի միջոցով մենք կարող ենք հանգիստ սրտով գումարել երկուական թվեր, հաշվի առնելով նախորդ գումարից առաջացած փոխանցումը։ Ավելի կոմպակտ նշանակում տանք մեր “լրիվ” գումարիչին․

Գումարիչի աշխատանքը ավելի լավ պատկերացնելու համար օգտվենք Վիկիպեդիայի անիմացիայից․

Վերջապես, համակցելով անհրաժեշտ քանակությամբ գումարիչներ, կարող ենք ստեղծել սահմանված բիտերով թվերի գումարիչներ, օրինակ 8֊բիտանոց գումարիչ սարք, որն արդեն իսկ մեծ առաջընթաց է (հաշվի առնելով, որ սարքը ստեղծում ենք ինքներս՝ տնային պայմաններում)։ Համակցելով 8֊բիտանոց գումարիչներ, կարող ենք ստեղծել 16֊ կամ 32-, կամ նույնիսկ՝ 64֊բիտանոց գումարիչներ։

Օրինակ, մեր գումարիչի կատարած արդյունքը տեսնելու համար կարող ենք նրան միացնել երկու լամպեր, որոնցից մեկը ցույց կտա S գումարը, իսկ մյուսը՝ CO փոխանցումը․

Իսկ հավաքելով մի քանի գումարիչներ, կստանանք, օրինակ 8-բիտանոց գումարիչ (նկարը նենգաբար պատճենվել է Փեթզոլդի գրքից)․

Այս 8-բիտանոց գումարիչը պետք է ունենա 9 լամպ, որոնցից 8֊ը ցույց կտան 8-բիտանոց թվերի սյունակների գումարի արդյունքները, իսկ 9րդ լամպը՝ վերջնական փոխանցումը։ Բավական թանկարժեք սարք է ստացվում, ընդամենը երկու 8֊բիտանոց թվեր գումարելու համար անհրաժեշտ է 9 լամպ, չհաշված մագնիսներն ու լարերը, այդ ամենի հետ մեկտեղ նաև, որ թվերը մուտքագրելու համար պետք է ձեռքով միացնել կամ անջատել համապատասխան բանալիները։ Այնուամենայնիվ, այս պահին մենք ի վիճակի ենք ստեղծել համակարգիչ, լավ, սարք, որը գումարում է 8֊բիտանոց երկուական թվեր, սակայն հիշելով վերևում այն դատողությունները, որ “հանում” հնարավոր է կազմակերպել հիմնվելով գումարման վրա, կամ բազմապատկում հնարավոր է կազմակերպել հիմնվելով գումարման վրա, կամ բաժանում՝ հաշվելով հանումների քանակը, ապա համեստորեն կարող ենք պնդել, որ ի զորու ենք ստեղծել պարզագույն հաշվիչ մեքենա, կամ, որ ավելի ստույգ է՝ հավաքել հաշվիչ մեքենա, տնային պայմաններում։

Հարց է ծագում, թե ինչու է այդ դեպքում Intel֊ի (կամ ցանկացած այլ պրոցեսոր արտադրող ընկերության) պրոցեսորը լուցկու տուփից փոքր, իսկ մեր խղճուկ գումարիչը կազմված տասնյակ մագնիսներից, լարերից ու լամպերից։ Դրա հետ մեկտեղ, Intel֊ի պրոցեսորը կարող է կատարել շատ ավելի բարդ գործողություններ, քան հասարակ գումարումը, ու կարող է դա անել շատ ավելի արագ, քան կհասցնի վառվել մեր գումարիչի լամպը։ Պատճառներից մեկն այն է, որ էլեկտրամագնիսական ռելե վաղուց արդեն չի օգտագործվում արդի պրոցեսորների ստեղծման համար։ Ավելին, անիմաստ է օգտագործել այն, եթե իհարկե օգտագործման նպատակը ուսումնական բնույթ չի կրում։ Մեր դեպքում, մոռանանք, որ մի պահ ցանկություն էինք հայտնել մրցել Intel֊ի հետ, ու տեսնենք թե ինչ տեսք կունենա համակարգիչը ռելեների հիման վրա․

Սա Հարրի Փորթերն է (չխառնել կախարդի հետ), ով հպարտորեն լուսանկարվել է իր ստեղծած ռելեներով համակարգչի հետ։ Ահա այսպիսի տեսք կունենա մեր համակարգիչը, եթե շարունակենք այն կառուցել։ Պրոցեսորները օգտագործում են տրանզիստորներ ռելեների փոխարեն։ Տրանզիստորը կիսահաղորդիչ սարք է։ Վիկիպեդիան հուշում է, որ տրանզիստորը սովորաբար օգտագործվում է էլեկտրական ազդանշանների ուժեղացման կամ փոխանջատման համար։ Ռելեն հնարավոր բոլոր ուղղություններով զիջում է տրանզիստորին, տրանզիստորն ավելի մատչելի է, համեմատաբար անաղմուկ, ավելի քիչ էներգիա օգտագործող և, որ ամենակարևորն է՝ փոքր։ Տրանզիստորների աշխատանքի սկզբունքներին կարող եք ծանոթանալ որոնելով համապատասխան նյութեր, մենք ընդամենը նշենք, որ տրանզիստորը իր չափով շատ շատ անգամներ փոքր է ռելեյի չափերից, հետևաբար և արդի պրոցեսորը ի վիճակի է լինել լուցկու տուփից փոքր չափերի։ Վերջին ձեռքբերումները հուշում են, որ մեկ տրանզիստորի չափը կարող է լինել 5 նանոմետր, 5, նանո, մետր, իսկ քանակապես, օրինակ, Intel Core 2 շարքում տրանզիստորների քանակը կարող է հասնել մոտ 300 միլիոնի, իսկ Intel Core i7 (Quad) պարունակում է 791 միլիոն տրանզիստոր, պատկերացրեք նույն քանակի էլեկտրամագնիսական ռելեներով կազմված շղթաներ։ Այո, միանշանակ Intel֊ի հետ պրոցեսորների շուկայում մրցելը անիմաստ զբաղմունք է, մասնավորապես եթե մեր պրոցեսորը լինելու է ռելեների հիման վրա։

Հաջորդ հոդվածներում մանրամասն կդիտարկենք մեքենայական կոդի կառուցվածքը։

Հետևեք մեր պաշտոնական էջերին

Medium: https://medium.com/code-republic
Medium Tech Blog: https://medium.com/code-republic-techblog
Facebook: https://www.facebook.com/coderepublicam
Instagram: https://instagram.com/coderepublic.am
LinkedIn: https://www.linkedin.com/company/code-republic-am/
YouTube: https://www.youtube.com/c/CodeRepublic