Օպերացիոն համակարգերի ներածություն

Հե՜յ Հաբր։ Ձեր ուշադրությանն եմ ներկայացնում իմ կարծիքով մեկ հետաքրքիր գրականության՝ OSTEP-ի հոդված-թարգմանությունների շարքը։ Այս նյութը բավականին խորը քննարկում է unix-ի նման օպերացիոն համակարգերի աշխատանքը, այն է՝ պրոցեսների, տարբեր ժամանակացույցերի, հիշողության և այլ նմանատիպ բաղադրիչների հետ աշխատանքը, որոնք կազմում են ժամանակակից ՕՀ: Բոլոր նյութերի բնօրինակը կարող եք տեսնել այստեղ այստեղ. Խնդրում եմ նկատի ունենալ, որ թարգմանությունը կատարվել է ոչ պրոֆեսիոնալ (բավականին ազատ), բայց հուսով եմ պահպանել եմ ընդհանուր իմաստը։

Այս թեմայով լաբորատոր աշխատանք կարելի է գտնել այստեղ.
- բնօրինակը: pages.cs.wisc.edu/~remzi/OSTEP/Homework/homework.html
- բնօրինակը: github.com/remzi-arpacidusseau/ostep-code
- իմ անձնական հարմարվողականությունը. github.com/bykvaadm/OS/tree/master/ostep

Կարող եք նաև դիտել իմ ալիքը հեռագիր =)

Ծրագրի շահագործում

Ի՞նչ է տեղի ունենում, երբ ծրագիրն աշխատում է: Գործող ծրագիրն անում է մի պարզ բան՝ այն կատարում է հրահանգներ: Ամեն վայրկյան միլիոնավոր և նույնիսկ, հնարավոր է, միլիարդավոր հրահանգներ պրոցեսորը վերցվում է RAM-ից, այն իր հերթին վերծանում է դրանք (օրինակ՝ ճանաչում է, թե որ տեսակին են պատկանում այս հրահանգները) և կատարում դրանք։ Սա կարող է լինել երկու թվերի ավելացում, հիշողություն մուտք գործելու, պայմանի ստուգում, ֆունկցիայի ցատկում և այլն: Մեկ հրահանգի կատարումից հետո պրոցեսորն անցնում է մյուսի կատարմանը: Եվ այսպես, հրահանգների հետևից, դրանք կատարվում են մինչև ծրագրի ավարտը:
Այս օրինակը բնականաբար համարվում է պարզեցված. փաստորեն, պրոցեսորն արագացնելու համար ժամանակակից սարքաշարը թույլ է տալիս կատարել հրահանգներ առանց հերթի, հաշվարկել հնարավոր արդյունքները, միաժամանակ կատարել հրահանգներ և նմանատիպ հնարքներ:

Ֆոն Նեյմանի հաշվարկման մոդելը

Մեր կողմից նկարագրված աշխատանքի պարզեցված ձևը նման է ֆոն Նեյմանի հաշվարկման մոդելին։ Ֆոն Նոյմանը համակարգչային համակարգերի առաջամարտիկներից է, նա նաև խաղերի տեսության հեղինակներից է։. Ծրագրի գործարկման ընթացքում տեղի են ունենում մի շարք այլ իրադարձություններ, շատ այլ գործընթացներ և երրորդ կողմի տրամաբանական աշխատանքներ, որոնց հիմնական նպատակն է պարզեցնել համակարգի գործարկումը, շահագործումը և սպասարկումը:
Կա մի շարք ծրագրեր, որոնք պատասխանատու են ծրագրերը հեշտ գործարկելու համար (կամ նույնիսկ թույլ են տալիս մի քանի ծրագրեր միաժամանակ գործարկել), որը թույլ է տալիս ծրագրերին կիսել նույն հիշողությունը և շփվել տարբեր սարքերի հետ: Ծրագրային ապահովման (ծրագրային ապահովման) նման հավաքածուն, ըստ էության, կոչվում է օպերացիոն համակարգ, և նրա խնդիրները ներառում են համակարգի ճիշտ և արդյունավետ աշխատանքի մոնիտորինգ, ինչպես նաև այս համակարգի կառավարման հեշտության ապահովում:

Օպերացիոն համակարգ

Օպերացիոն համակարգը, որը հապավում է OS, փոխկապակցված ծրագրերի մի շարք է, որոնք նախատեսված են համակարգչային ռեսուրսները կառավարելու և օգտատիրոջ փոխգործակցությունը համակարգչի հետ կազմակերպելու համար:.
ՕՀ-ն իր արդյունավետությանը հասնում է առաջին հերթին՝ ամենակարևոր տեխնիկայի՝ տեխնիկայի միջոցով վիրտուալացում. ՕՀ-ն փոխազդում է ֆիզիկական ռեսուրսի հետ (պրոցեսոր, հիշողություն, սկավառակ և այլն) և այն վերածում է ավելի ընդհանուր, ավելի հզոր և ավելի հեշտ օգտագործման ձևի: Հետևաբար, ընդհանուր հասկանալու համար կարող եք շատ կոպիտ համեմատել օպերացիոն համակարգը վիրտուալ մեքենայի հետ:
Որպեսզի օգտագործողներին թույլատրվի հրամաններ տալ օպերացիոն համակարգին և այդպիսով օգտագործել վիրտուալ մեքենայի հնարավորությունները (օրինակ՝ ծրագիր գործարկելը, հիշողությունը հատկացնելը, ֆայլ մուտք գործելը և այլն), օպերացիոն համակարգը տրամադրում է որոշակի միջերես, որը կոչվում է. API (հավելվածի ծրագրավորման ինտերֆեյս) և որին կարող եք զանգեր կատարել (զանգել): Տիպիկ օպերացիոն համակարգը թույլ է տալիս հարյուրավոր համակարգային զանգեր կատարել:
Վերջապես, քանի որ վիրտուալացումը թույլ է տալիս մի քանի ծրագրերի գործարկել (այդպիսով կիսելով պրոցեսորը), և միաժամանակ մուտք գործել դրանց հրահանգներ և տվյալներ (այդպիսով կիսելով հիշողությունը), և մուտք գործել սկավառակներ (այդպիսով կիսելով I/O սարքերը), օպերացիոն համակարգը նաև կոչվում է. ռեսուրսների կառավարիչ: Յուրաքանչյուր պրոցեսոր, սկավառակ և հիշողություն համակարգի ռեսուրսն է, և, հետևաբար, օպերացիոն համակարգի դերերից մեկը դառնում է այդ ռեսուրսները կառավարելու խնդիրը՝ դա անելով արդյունավետ, ազնվորեն կամ հակառակը՝ կախված նրանից, թե ինչ խնդիր է այս օպերացիոն համակարգը: նախագծված է.

CPU-ի վիրտուալացում

Դիտարկենք հետևյալ ծրագիրը.
(https://www.youtube.com/watch?v=zDwT5fUcki4&feature=youtu.be)

Այն ոչ մի հատուկ գործողություններ չի կատարում, իրականում այն ​​ընդամենը ֆունկցիա է կանչում վազել(), որի խնդիրն է շրջել ժամանակի ստուգման միջով և մեկ վայրկյան անցնելուց հետո վերադառնալ: Այսպիսով, այն անորոշ ժամանակով կրկնում է այն տողը, որն օգտագործողը փոխանցել է որպես արգումենտ։
Եկեք գործարկենք այս ծրագիրը և որպես փաստարկ փոխանցենք «A» նիշը: Արդյունքն առանձնապես հետաքրքիր չէ. համակարգը պարզապես իրականացնում է ծրագիր, որը պարբերաբար ցուցադրում է «A» նիշը:
Հիմա եկեք փորձենք տարբերակը, երբ նույն ծրագրի բազմաթիվ օրինակներ են աշխատում, բայց տարբեր տառեր են թողարկում՝ ավելի պարզ դարձնելու համար: Այս դեպքում արդյունքը որոշակիորեն տարբեր կլինի։ Չնայած այն հանգամանքին, որ մենք ունենք մեկ պրոցեսոր, ծրագիրը կատարվում է միաժամանակ: Ինչպե՞ս է դա տեղի ունենում: Բայց պարզվում է, որ օպերացիոն համակարգը, ոչ առանց ապարատային հնարավորությունների օգնության, պատրանք է ստեղծում։ Պատրանքը, որ համակարգն ունի բազմաթիվ վիրտուալ պրոցեսորներ, որոնք մեկ ֆիզիկական պրոցեսորը վերածում են տեսականորեն անսահման թվի և դրանով իսկ թույլ են տալիս թվացյալ ծրագրերին միաժամանակ աշխատել: Այս պատրանքը կոչվում է CPU-ի վիրտուալացում.
Այս նկարը շատ հարցեր է առաջացնում, օրինակ՝ եթե մի քանի ծրագիր ցանկանան միաժամանակ գործարկել, ո՞ր մեկն է գործարկվելու։ Այս հարցի պատասխանատուն ՕՀ-ի «քաղաքականությունն է»: Քաղաքականություններն օգտագործվում են ՕՀ-ի շատ վայրերում և պատասխանում են նման հարցերի, և հանդիսանում են ՕՀ-ի կիրառման հիմնական մեխանիզմները: Այստեղից էլ ՕՀ-ի դերը որպես ռեսուրսների կառավարիչ:

Հիշողության վիրտուալացում

Հիմա եկեք նայենք հիշողությանը: Հիշողության ֆիզիկական մոդելը ժամանակակից համակարգերում ներկայացված է որպես բայթերի զանգված:. Հիշողությունից կարդալու համար անհրաժեշտ է նշել բջջային հասցենմուտք գործելու համար: Տվյալները գրելու կամ թարմացնելու համար պետք է նաև նշեք տվյալները և այն բջջի հասցեն, որտեղ դրանք պետք է գրվեն:
Ծրագրի կատարման ընթացքում հիշողությունը մշտապես հասանելի է դառնում: Ծրագիրը պահպանում է իր ամբողջ տվյալների կառուցվածքը հիշողության մեջ և մուտք է գործում այն՝ կատարելով տարբեր հրահանգներ: Միևնույն ժամանակ, հրահանգները նույնպես պահվում են հիշողության մեջ, ուստի այն հասանելի է նաև հաջորդ հրահանգի յուրաքանչյուր հարցման համար:

malloc() զանգ

Դիտարկենք հետևյալ ծրագիրը, որը զանգի միջոցով հատկացնում է հիշողության շրջան malloc () (https://youtu.be/jnlKRnoT1m0):

Ծրագիրը մի քանի բան է անում. Նախ, այն հատկացնում է որոշակի հիշողություն (տող 7), այնուհետև տպում է հատկացված բջիջի հասցեն (տող 9), զրո է գրում հատկացված հիշողության առաջին բնիկին։ Այնուհետև ծրագիրը մտնում է մի օղակ, որտեղ այն ավելացնում է «p» փոփոխականի հասցեի հիշողության մեջ պահվող արժեքը: Այն նաև ինքն է տպում գործընթացի ID-ն: Գործընթացի ID-ն եզակի է յուրաքանչյուր գործող գործընթացի համար. Մի քանի օրինակ թողարկելով՝ մենք կբախվենք հետաքրքիր արդյունքի. առաջին դեպքում, եթե ոչինչ չանեք և պարզապես գործարկեք մի քանի օրինակ, ապա հասցեները տարբեր կլինեն: Բայց սա մեր տեսության տակ չի մտնում։ Ճիշտ է, քանի որ ժամանակակից բաշխումները լռելյայն միացված են հիշողության պատահականացումը: Եթե ​​այն անջատված է, մենք ստանում ենք ակնկալվող արդյունքը` միաժամանակ գործող երկու ծրագրերի հիշողության հասցեները կհամընկնեն:

Արդյունքում պարզվում է, որ երկու անկախ ծրագրեր աշխատում են իրենց մասնավոր հասցեների տարածություններով, որոնք իրենց հերթին օպերացիոն համակարգի կողմից քարտեզագրվում են ֆիզիկական հիշողության մեջ։. Հետևաբար, մեկ ծրագրի շրջանակներում հիշողության հասցեների օգտագործումը որևէ կերպ չի ազդի մյուսների վրա, և յուրաքանչյուր ծրագրին թվում է, թե այն ունի իր ֆիզիկական հիշողությունը, որն ամբողջությամբ տրված է իրեն: Իրականությունը, սակայն, այն է, որ ֆիզիկական հիշողությունը օպերացիոն համակարգի կողմից կառավարվող ընդհանուր ռեսուրս է:

Հետևողականություն

Օպերացիոն համակարգերում մեկ այլ կարևոր թեմաներից է հետեւողականություն. Այս տերմինն օգտագործվում է համակարգում առկա խնդիրների մասին խոսելիս, որոնք կարող են առաջանալ միևնույն ծրագրի շրջանակներում շատ բաների հետ միաժամանակ աշխատելիս: Հետևողականության հետ կապված խնդիրներ առաջանում են նույնիսկ օպերացիոն համակարգի ներսում: Հիշողության և պրոցեսորի վիրտուալացման նախորդ օրինակներում մենք հասկացանք, որ ՕՀ-ն միաժամանակ շատ բաներ է կառավարում՝ սկսում է առաջին պրոցեսը, հետո երկրորդը և այլն: Ինչպես պարզվեց, այս պահվածքը կարող է հանգեցնել որոշ խնդիրների։ Այսպիսով, օրինակ, ժամանակակից բազմաթելային ծրագրերը նման դժվարություններ են ունենում:

Դիտարկենք հետևյալ ծրագիրը.

Ծրագիրը հիմնական գործառույթում ստեղծում է երկու թեմա՝ օգտագործելով զանգը pthread_create(). Այս օրինակում շարանը կարելի է դիտարկել որպես միևնույն հիշողության տարածքում այլ գործառույթների կողքին աշխատող ֆունկցիա, որտեղ հստակորեն գործում են մեկից ավելի գործառույթներ միաժամանակ: Այս օրինակում յուրաքանչյուր շարանը սկսում և կատարում է գործառույթը worker(), որն իր հերթին պարզապես ավելացնում է փոփոխականը,.

Եկեք գործարկենք այս ծրագիրը 1000 արգումենտով: Ինչպես կարող էիք կռահել, արդյունքը պետք է լինի 2000, քանի որ յուրաքանչյուր շարանը փոփոխականը մեծացրել է 1000 անգամ: Այնուամենայնիվ, ամեն ինչ այնքան էլ պարզ չէ. Փորձենք ծրագիրը գործարկել մեծության կարգով ավելի շատ կրկնություններով:

Մուտքագրելով թիվ, օրինակ՝ 100000, մենք ակնկալում ենք, որ արդյունքը կտեսնենք որպես 200000 թիվը: Այնուամենայնիվ, եթե մի քանի անգամ գործարկենք 100000 թիվը, մենք ոչ միայն չենք տեսնի ճիշտ պատասխանը, այլև կստանանք տարբեր սխալ պատասխաններ: Պատասխանը կայանում է նրանում, որ թիվը մեծացնելու համար անհրաժեշտ է երեք գործողություն՝ թվի արդյունահանում հիշողությունից, ավելացում և այնուհետև հետ գրել: Քանի որ այս բոլոր հրահանգները չեն կատարվում ատոմային եղանակով (բոլորը միաժամանակ), նման տարօրինակ բաներ կարող են տեղի ունենալ: Այս խնդիրը կոչվում է ծրագրավորման մեջ մրցավազքի վիճակը. Երբ անհայտ ուժերը անհայտ պահին կարող են ազդել ձեր ցանկացած գործողության կատարման վրա:

Source: www.habr.com