ოპერაციული სისტემების შესავალი

ჰეი ჰაბრ! მინდა თქვენს ყურადღებას გავამახვილო ჩემი აზრით ერთი საინტერესო ლიტერატურის - OSTEP-ის სტატია-თარგმანის სერია. ეს მასალა საკმაოდ ღრმად განიხილავს unix-ის მსგავსი ოპერაციული სისტემების მუშაობას, კერძოდ, პროცესებთან, სხვადასხვა გრაფიკებთან, მეხსიერებასთან და სხვა მსგავს კომპონენტებთან მუშაობას, რომლებიც ქმნიან თანამედროვე OS-ს. ყველა მასალის ორიგინალი შეგიძლიათ ნახოთ აქ აქ. გთხოვთ გაითვალისწინოთ, რომ თარგმანი შესრულებულია არაპროფესიონალურად (საკმაოდ თავისუფლად), მაგრამ იმედია შევინარჩუნე ზოგადი მნიშვნელობა.

ამ თემაზე ლაბორატორიული სამუშაოები შეგიძლიათ იხილოთ აქ:

• ორიგინალური: pages.cs.wisc.edu/~remzi/OSTEP/Homework/homework.html
• ორიგინალური: github.com/remzi-arpacidusseau/ostep-code
• ჩემი პირადი ადაპტაცია: github.com/bykvaadm/OS/tree/master/ostep

სხვა ნაწილები:

• ნაწილი 1: შესავალი

ასევე შეგიძლიათ ნახოთ ჩემი არხი აქ ტელეგრამა =)

მოდით შევხედოთ ყველაზე ფუნდამენტურ აბსტრაქციას, რომელსაც OS აძლევს მომხმარებლებს: პროცესი. პროცესის განმარტება საკმაოდ მარტივია - ასეა გაშვებული პროგრამა. პროგრამა თავისთავად არის უსიცოცხლო ნივთი, რომელიც მდებარეობს დისკზე - ეს არის ინსტრუქციების ნაკრები და, შესაძლოა, რამდენიმე სტატიკური მონაცემი, რომელიც ელოდება გაშვებას. ეს არის OS, რომელიც იღებს ამ ბაიტებს და აწარმოებს მათ, გარდაქმნის პროგრამას რაიმე სასარგებლოდ.
ყველაზე ხშირად, მომხმარებლებს სურთ ერთზე მეტი პროგრამის ერთდროულად გაშვება, მაგალითად, შეგიძლიათ გაუშვათ ბრაუზერი, თამაში, მედია ფლეერი, ტექსტური რედაქტორი და მსგავსი თქვენს ლეპტოპზე. სინამდვილეში, ტიპურ სისტემას შეუძლია ათობით ან ასობით პროცესის ერთდროულად გაშვება. ეს ფაქტი აადვილებს სისტემის გამოყენებას, თქვენ არასოდეს უნდა ინერვიულოთ იმაზე, არის თუ არა CPU უფასო, თქვენ უბრალოდ აწარმოებთ პროგრამებს.

ეს აჩენს პრობლემას: როგორ შევქმნათ მრავალი CPU-ის ილუზია? როგორ შეუძლია OS-მ შექმნას თითქმის უსასრულო რაოდენობის CPU-ის ილუზია, თუნდაც მხოლოდ ერთი ფიზიკური CPU გქონდეთ?

OS ქმნის ამ ილუზიას CPU ვირტუალიზაციის საშუალებით. ერთი პროცესის დაწყებით, შემდეგ მისი შეჩერებით, სხვა პროცესის დაწყებით და ა.შ. OS-ს შეუძლია შეინარჩუნოს ილუზია, რომ ბევრი ვირტუალური პროცესორია, მაშინ როცა რეალურად იქნება ერთი ან მეტი ფიზიკური პროცესორი. ამ ტექნიკას ე.წ CPU რესურსების დაყოფა დროის მიხედვით. ეს ტექნიკა საშუალებას აძლევს მომხმარებლებს განახორციელონ იმდენი ერთდროულად პროცესი, რამდენიც სურთ. ამ გადაწყვეტის ღირებულება არის შესრულება - ვინაიდან თუ CPU იზიარებს რამდენიმე პროცესს, თითოეული პროცესი უფრო ნელა დამუშავდება.
CPU-ის ვირტუალიზაციის განსახორციელებლად და განსაკუთრებით კარგად გასაკეთებლად, OS-ს სჭირდება როგორც დაბალი, ასევე მაღალი დონის მხარდაჭერა. დაბალი დონის მხარდაჭერა ეწოდება მექანიზმები არის დაბალი დონის მეთოდები ან პროტოკოლები, რომლებიც ახორციელებენ ფუნქციის საჭირო ნაწილს. ასეთი ფუნქციონირების მაგალითია კონტექსტის გადართვა, რაც OS-ს აძლევს შესაძლებლობას შეაჩეროს ერთი პროგრამა და გაუშვას სხვა პროგრამა პროცესორზე. ეს დროის დაყოფა დანერგილია ყველა თანამედროვე ოპერაციულ სისტემაში.
ამ მექანიზმების თავზე არის გარკვეული ლოგიკა ჩაშენებული OS-ში, „პოლიტიკის“ სახით. პოლიტიკა არის გარკვეული გადაწყვეტილების მიღების ალგორითმი ოპერაციული სისტემისთვის. ასეთი პოლიტიკა, მაგალითად, წყვეტს, რომელი პროგრამა უნდა დაიწყოს (ბრძანებების სიიდან) ჯერ. ასე, მაგალითად, ეს პრობლემა მოგვარდება პოლიტიკით ე.წ გრაფიკი (დაგეგმვის პოლიტიკა) ხოლო გადაწყვეტის არჩევისას ის იხელმძღვანელებს ისეთი მონაცემებით, როგორიცაა: გაშვების ისტორია (რომელი პროგრამა ამოქმედდა ყველაზე ხანგრძლივად ბოლო წუთებში), რა დატვირთვას ატარებს ეს პროცესი (რა ტიპის პროგრამები დაიწყო), შესრულების მეტრიკა (სისტემაა თუ არა ოპტიმიზებულია ინტერაქტიული ურთიერთქმედებისთვის ან გამტარუნარიანობისთვის) და ა.შ.

აბსტრაქცია: პროცესი

ოპერაციული სისტემის მიერ შესრულებული გაშვებული პროგრამის აბსტრაქცია არის ის, რასაც ჩვენ ვუწოდებთ პროცესი. როგორც უკვე აღვნიშნეთ, პროცესი უბრალოდ გაშვებული პროგრამაა, დროის ნებისმიერ მყისიერ პერიოდში. პროგრამა, რომლითაც ჩვენ შეგვიძლია მივიღოთ შემაჯამებელი ინფორმაცია სხვადასხვა სისტემის რესურსებიდან, რომლებზეც ეს პროგრამა წვდება ან გავლენას ახდენს მისი შესრულების დროს.
პროცესის კომპონენტების გასაგებად, თქვენ უნდა გესმოდეთ სისტემის მდგომარეობა: რისი წაკითხვა ან შეცვლა შეუძლია პროგრამას მისი მუშაობის დროს. ნებისმიერ დროს, თქვენ უნდა გესმოდეთ, სისტემის რომელი ელემენტებია მნიშვნელოვანი პროგრამის შესრულებისთვის.
სისტემის ერთ-ერთი აშკარა ელემენტი, რომელსაც პროცესი მოიცავს არის память. ინსტრუქციები განთავსებულია მეხსიერებაში. ინფორმაცია, რომელსაც პროგრამა კითხულობს ან წერს, ასევე მდებარეობს მეხსიერებაში. ამრიგად, მეხსიერება, რომელსაც პროცესს შეუძლია მიმართოს (ე.წ. მისამართების სივრცე) არის პროცესის ნაწილი.
ასევე სისტემის მდგომარეობის ნაწილია რეგისტრები. ბევრი ინსტრუქცია მიზნად ისახავს რეგისტრების მნიშვნელობის შეცვლას ან მათი მნიშვნელობის წაკითხვას და, ამრიგად, რეგისტრები ასევე ხდება პროცესის მუშაობის მნიშვნელოვანი ნაწილი.
უნდა აღინიშნოს, რომ მანქანის მდგომარეობა ასევე ყალიბდება სპეციალური რეგისტრებიდან. Მაგალითად, IP - ინსტრუქციის მაჩვენებელი — მითითება იმ ინსტრუქციისა, რომელსაც პროგრამა ამჟამად ახორციელებს. Არსებობს ასევე დასტის მაჩვენებელი და მასთან დაკავშირებული ჩარჩო მაჩვენებელი, რომლებიც გამოიყენება სამართავად: ფუნქციის პარამეტრების, ლოკალური ცვლადების და მისამართების დასაბრუნებლად.
და ბოლოს, პროგრამები ხშირად წვდებიან ROM-ს (მხოლოდ წაკითხვის მეხსიერებას). ეს „I/O“ (შესვლა/გამომავალი) ინფორმაცია უნდა შეიცავდეს პროცესის დროს გახსნილი ფაილების სიას.

პროცესის API

იმისათვის, რომ გავაუმჯობესოთ ჩვენი გაგება, თუ როგორ მუშაობს პროცესი, მოდით შევისწავლოთ სისტემური ზარების მაგალითები, რომლებიც უნდა იყოს ჩართული ნებისმიერი ოპერაციული სისტემის ინტერფეისში. ეს API ხელმისაწვდომია ამა თუ იმ ფორმით ნებისმიერ OS-ზე.

● შექმნა (შექმნა): OS უნდა შეიცავდეს მეთოდს, რომელიც საშუალებას მოგცემთ შექმნათ ახალი პროცესები. როდესაც ტერმინალში შეიყვანთ ბრძანებას ან გაუშვით აპლიკაციას ხატულაზე ორჯერ დაწკაპუნებით, ზარი ეგზავნება OS-ს ახალი პროცესის შესაქმნელად და შემდეგ გაუშვით მითითებული პროგრამა.
● მოცილება: ვინაიდან არსებობს პროცესის შექმნის ინტერფეისი, OS-მ ასევე უნდა უზრუნველყოს პროცესის იძულებითი წაშლის შესაძლებლობა. პროგრამების უმეტესობა ბუნებრივად დაიწყება და წყდება თავისით გაშვებისას. წინააღმდეგ შემთხვევაში მომხმარებელს სურს მათი მოკვლა და ამით პროცესის შეჩერების ინტერფეისი სასარგებლო იქნება.
● დაელოდეთ (მოლოდინი): ზოგჯერ სასარგებლოა პროცესის დასრულებამდე ლოდინი, ამიტომ მოწოდებულია რამდენიმე ინტერფეისი, რომელიც უზრუნველყოფს ლოდინის შესაძლებლობას.
● სხვადასხვა კონტროლი (სხვადასხვა კონტროლი): გარდა მკვლელობისა და პროცესის მოლოდინისა, არსებობს სხვა სხვადასხვა კონტროლის მეთოდებიც. მაგალითად, ოპერაციული სისტემების უმეტესობა იძლევა პროცესის გაყინვის (გარკვეული პერიოდის განმავლობაში მისი შესრულების შეჩერების) და შემდეგ მისი განახლების (შესრულების გაგრძელება) შესაძლებლობას.
● სტატუსი (მდგომარეობა): არსებობს სხვადასხვა ინტერფეისი, რათა მიიღოთ გარკვეული ინფორმაცია პროცესის სტატუსის შესახებ, მაგალითად, რამდენი ხანია მუშაობს ან რა მდგომარეობაშია ამჟამად.

პროცესის შექმნა: დეტალები

ერთ-ერთი საინტერესო ის არის, თუ როგორ ხდება პროგრამების ტრანსფორმაცია პროცესებად. განსაკუთრებით ის, თუ როგორ აიღებს და აწარმოებს პროგრამას OS. ზუსტად როგორ იქმნება პროცესი.
უპირველეს ყოვლისა, OS-მ უნდა ჩატვირთოს პროგრამის კოდი და სტატიკური მონაცემები მეხსიერებაში (პროცესის მისამართის სივრცეში). პროგრამები ჩვეულებრივ განლაგებულია დისკზე ან მყარი მდგომარეობის დისკზე რაიმე შესრულებადი ფორმატში. ამრიგად, პროგრამისა და სტატიკური მონაცემების მეხსიერებაში ჩატვირთვის პროცესი მოითხოვს OS-ს შეეძლოს წაიკითხოს ეს ბაიტები დისკიდან და განათავსოს ისინი სადმე მეხსიერებაში.

ადრეულ ოპერაციულ სისტემებში ჩატვირთვის პროცესი გულმოდგინედ ხდებოდა, რაც იმას ნიშნავს, რომ მთელი კოდი იტვირთებოდა მეხსიერებაში პროგრამის გაშვებამდე. თანამედროვე ოპერაციული სისტემები ამას ზარმაცად აკეთებენ, ანუ იტვირთება კოდის ან მონაცემების მხოლოდ მაშინ, როდესაც პროგრამა მოითხოვს მათ შესრულების დროს.

მას შემდეგ, რაც კოდი და სტატიკური მონაცემები ჩაიტვირთება OS მეხსიერებაში, არის კიდევ რამდენიმე რამ, რაც უნდა გაკეთდეს პროცესის გაშვებამდე. მეხსიერების გარკვეული რაოდენობა უნდა იყოს გამოყოფილი სტეკისთვის. პროგრამები იყენებენ დასტას ლოკალური ცვლადების, ფუნქციის პარამეტრებისა და დაბრუნების მისამართებისთვის. OS გამოყოფს ამ მეხსიერებას და აძლევს მას პროცესს. სტეკი ასევე შეიძლება გამოიყოს რამდენიმე არგუმენტით, კონკრეტულად ის ავსებს main() ფუნქციის პარამეტრებს, მაგალითად argc და argv მასივით.

ოპერაციულმა სისტემამ ასევე შეიძლება გამოყოს გარკვეული მეხსიერება პროგრამის გროვაზე. გროვა გამოიყენება პროგრამების მიერ დინამიურად განაწილებული მონაცემების მკაფიოდ მოთხოვნის მიზნით. პროგრამები ითხოვენ ამ ადგილს ფუნქციის გამოძახებით malloc () და ასუფთავებს მას აშკარად ფუნქციის გამოძახებით უფასო (). გროვა საჭიროა მონაცემთა სტრუქტურებისთვის, როგორიცაა დაკავშირებული ფურცლები, ჰეშის ცხრილები, ხეები და სხვა. თავდაპირველად, მეხსიერების მცირე რაოდენობა ეთმობა გროვას, მაგრამ დროთა განმავლობაში, პროგრამის გაშვებისას, გროვას შეუძლია მოითხოვოს მეტი მეხსიერება ბიბლიოთეკის API-ის გამოძახებით malloc(). ოპერაციული სისტემა ჩართულია მეტი მეხსიერების გამოყოფის პროცესში ამ ზარების დასაკმაყოფილებლად.

ოპერაციული სისტემა ასევე შეასრულებს ინიციალიზაციის ამოცანებს, განსაკუთრებით I/O-სთან დაკავშირებულ ამოცანებს. მაგალითად, UNIX სისტემებზე, თითოეულ პროცესს ნაგულისხმევად აქვს 3 ღია ფაილის დესკრიპტორი, სტანდარტული შეყვანისთვის, გამომავალი და შეცდომისთვის. ეს სახელურები პროგრამებს საშუალებას აძლევს წაიკითხონ ტერმინალიდან შეყვანილი ინფორმაცია, ასევე აჩვენონ ინფორმაცია ეკრანზე.

ამრიგად, კოდისა და სტატიკური მონაცემების მეხსიერებაში ჩატვირთვის, სტეკის შექმნით და ინიციალიზაციის გზით, და სხვა სამუშაოს შესრულებით, რომელიც დაკავშირებულია I/O ამოცანების შესრულებასთან, OS ამზადებს ეტაპს პროცესის შესასრულებლად. დაბოლოს, დარჩა ერთი ბოლო დავალება: პროგრამის გაშვება მის შესასვლელ წერტილში, რომელსაც ეწოდება main() ფუნქცია. main() ფუნქციის შესრულებით, OS გადასცემს CPU კონტროლს ახლად შექმნილ პროცესზე, რითაც პროგრამა იწყებს შესრულებას.

პროცესის მდგომარეობა

ახლა, როდესაც ჩვენ გვაქვს გარკვეული გაგება, თუ რა არის პროცესი და როგორ იქმნება ის, მოდით ჩამოვთვალოთ პროცესის მდგომარეობა, რომელშიც ის შეიძლება იყოს. უმარტივესი ფორმით, პროცესი შეიძლება იყოს ერთ-ერთ ასეთ მდგომარეობაში:
● სირბილი. გაშვებისას პროცესი მუშაობს პროცესორზე. ეს ნიშნავს, რომ ინსტრუქციები სრულდება.
● Ready. მზა მდგომარეობაში, პროცესი მზად არის გასაშვებად, მაგრამ რატომღაც OS არ ახორციელებს მას მითითებულ დროს.
● დაბლოკილ. დაბლოკილ მდგომარეობაში, პროცესი ასრულებს ზოგიერთ ოპერაციებს, რომლებიც ხელს უშლის მის შესასრულებლად მზადყოფნას, სანამ რაიმე მოვლენა არ მოხდება. ერთი გავრცელებული მაგალითია, როდესაც პროცესი იწყებს IO ოპერაციას, ის იბლოკება ისე, რომ სხვა პროცესს შეუძლია გამოიყენოს პროცესორი.

თქვენ შეგიძლიათ წარმოიდგინოთ ეს მდგომარეობები გრაფიკის სახით. როგორც სურათზე ვხედავთ, პროცესის მდგომარეობა შეიძლება შეიცვალოს RUNNING-სა და READY-ს შორის OS-ის შეხედულებისამებრ. როდესაც პროცესის მდგომარეობა იცვლება READY-დან გაშვებამდე, ეს ნიშნავს, რომ პროცესი დაგეგმილია. საპირისპირო მიმართულებით - ამოღებულია განლაგებიდან. იმ მომენტში, როდესაც პროცესი დაბლოკილია, მაგალითად, მე ვიწყებ IO ოპერაციას, OS შეინარჩუნებს მას ამ მდგომარეობაში, სანამ არ მოხდება რაიმე მოვლენა, მაგალითად, IO-ს დასრულება. ამ მომენტში გადასვლა მზა მდგომარეობაში და შესაძლოა დაუყოვნებლივ RUNNING მდგომარეობაზე, თუ OS ასე გადაწყვეტს.
მოდით შევხედოთ მაგალითს, თუ როგორ მოძრაობს ორი პროცესი ამ მდგომარეობებში. დასაწყისისთვის, წარმოვიდგინოთ, რომ ორივე პროცესი მუშაობს და თითოეული იყენებს მხოლოდ CPU-ს. ამ შემთხვევაში მათი სახელმწიფოები ასე გამოიყურება.

შემდეგ მაგალითში, პირველი პროცესი, გარკვეული დროის გაშვების შემდეგ, ითხოვს IO და შედის BLOCKED მდგომარეობაში, რაც საშუალებას აძლევს სხვა პროცესს გაუშვას (ნახ 1.4). OS ხედავს, რომ პროცესი 0 არ იყენებს CPU-ს და იწყებს პროცესს 1. სანამ პროცესი 1 მუშაობს, IO დასრულებულია და 0 პროცესის სტატუსი იცვლება READY. საბოლოოდ, პროცესი 1 დასრულდა და დასრულების შემდეგ პროცესი 0 იწყება, ახორციელებს და ამთავრებს თავის მუშაობას.

Მონაცემთა სტრუქტურა

ოპერაციული სისტემა თავისთავად არის პროგრამა და ისევე, როგორც ნებისმიერი სხვა პროგრამა, მას აქვს რამდენიმე ძირითადი მონაცემთა სტრუქტურა, რომელიც თვალყურს ადევნებს სხვადასხვა შესაბამის ინფორმაციას. თითოეული პროცესის მდგომარეობის თვალყურის დევნებისთვის, OS მხარს დაუჭერს ზოგიერთს პროცესის სია ყველა პროცესისთვის READY მდგომარეობაში და ზოგიერთი დამატებითი ინფორმაცია მიმდინარე პროცესების თვალყურის დევნებისთვის. ასევე, OS-მ უნდა აკონტროლოს დაბლოკილი პროცესები. IO დასრულების შემდეგ, OS-მ უნდა გააღვიძოს საჭირო პროცესი და დააყენოს ის გასაშვებად მზა მდგომარეობაში.

მაგალითად, OS-მ უნდა შეინარჩუნოს პროცესორის რეგისტრების მდგომარეობა. პროცესის გაჩერების მომენტში რეგისტრების მდგომარეობა ინახება პროცესის მისამართების სივრცეში და მისი მუშაობის გაგრძელების მომენტში აღდგება რეგისტრების მნიშვნელობები და ამით გრძელდება ამ პროცესის შესრულება.

მზა, დაბლოკილი, გაშვებული ქვეყნების გარდა, არის კიდევ რამდენიმე მდგომარეობა. ზოგჯერ, შექმნის დროს, პროცესი შეიძლება იყოს INIT მდგომარეობაში. საბოლოოდ, პროცესი შეიძლება განთავსდეს ფინალურ მდგომარეობაში, როდესაც ის უკვე დასრულებულია, მაგრამ მისი ინფორმაცია ჯერ არ არის გასუფთავებული. UNIX სისტემებზე ამ მდგომარეობას უწოდებენ ზომბების პროცესი. ეს მდგომარეობა სასარგებლოა იმ შემთხვევებში, როდესაც მშობლის პროცესს სურს იცოდეს ბავშვის დაბრუნების კოდი, მაგალითად, ჩვეულებრივ, 0 მიუთითებს წარმატებაზე და 1 შეცდომის შესახებ, მაგრამ პროგრამისტებს შეუძლიათ გამოსცეს დამატებითი გამომავალი კოდები სხვადასხვა პრობლემების სიგნალისთვის. როდესაც მშობელი პროცესი მთავრდება, ის აკეთებს საბოლოო სისტემურ ზარს, როგორიცაა wait(), დაელოდება ბავშვის პროცესის დასრულებას და სიგნალს აძლევს OS-ს, რომ მას შეუძლია გაასუფთავოს შეწყვეტილ პროცესთან დაკავშირებული ნებისმიერი მონაცემი.

ლექციის ძირითადი პუნქტები:

● პროცესი — გაშვებული პროგრამის მთავარი აბსტრაქცია OS-ში. ნებისმიერ დროს, პროცესი შეიძლება აღწერილი იყოს მისი მდგომარეობით: მეხსიერების შინაარსი მის მისამართთა სივრცეში, პროცესორის რეგისტრების შიგთავსი, ინსტრუქციის მაჩვენებლისა და სტეკის მაჩვენებლის ჩათვლით, და IO ინფორმაცია, როგორიცაა ღია ფაილების წაკითხვა ან ჩაწერა.
● პროცესის API შედგება ზარებისგან, რომლებიც პროგრამებს შეუძლიათ განახორციელონ პროცესებზე. როგორც წესი, ეს არის შექმნა, წაშლა ან სხვა ზარები.
● პროცესი მრავალ მდგომარეობიდან ერთ-ერთშია, მათ შორის გაშვებული, მზად, დაბლოკილი. სხვადასხვა მოვლენებს, როგორიცაა დაგეგმვა, გამონაკლისები დაგეგმვისგან ან ლოდინი, შეუძლია შეცვალოს პროცესის მდგომარეობა ერთიდან მეორეზე.
● პროცესის სია შეიცავს ინფორმაციას სისტემის ყველა პროცესის შესახებ. მასში თითოეულ ჩანაწერს ეწოდება პროცესის კონტროლის ბლოკი, რომელიც სინამდვილეში არის სტრუქტურა, რომელიც შეიცავს ყველა საჭირო ინფორმაციას კონკრეტული პროცესის შესახებ. 

წყარო: www.habr.com