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

გამარჯობა, ჰაბრ! თქვენს ყურადღებას მინდა წარმოგიდგინოთ ჩემი აზრით საინტერესო ერთი ლიტერატურის სტატია-თარგმანის სერია - 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

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

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

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

ფონ ნეუმანის გამოთვლის მოდელი

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

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

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

CPU ვირტუალიზაცია

განვიხილოთ შემდეგი პროგრამა:
(https://www.youtube.com/watch?v=zDwT5fUcki4&feature=youtu.be)

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

მეხსიერების ვირტუალიზაცია

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

malloc() ზარი

განვიხილოთ შემდეგი პროგრამა, რომელიც გამოყოფს მეხსიერების რეგიონს ზარის გამოყენებით malloc () (https://youtu.be/jnlKRnoT1m0):

პროგრამა რამდენიმე საქმეს აკეთებს. ჯერ გამოყოფს მეხსიერებას (სტრიქონი 7), შემდეგ ბეჭდავს გამოყოფილი უჯრედის მისამართს (სტრიქონი 9), წერს ნულს გამოყოფილი მეხსიერების პირველ სლოტზე. შემდეგი, პროგრამა შედის მარყუჟში, რომელშიც ის ზრდის მეხსიერებაში შენახულ მნიშვნელობას "p" ცვლადის მისამართზე. ის ასევე ბეჭდავს თავად პროცესის ID-ს. პროცესის ID უნიკალურია თითოეული მიმდინარე პროცესისთვის. რამდენიმე ასლის გაშვების შემდეგ, ჩვენ წავაწყდებით საინტერესო შედეგს: პირველ შემთხვევაში, თუ არაფერს აკეთებთ და უბრალოდ გაუშვით რამდენიმე ასლი, მაშინ მისამართები განსხვავებული იქნება. მაგრამ ეს ჩვენს თეორიას არ ექვემდებარება! სწორია, რადგან თანამედროვე დისტრიბუციებს აქვს ნაგულისხმევად ჩართული მეხსიერების რანდომიზაცია. თუ ის გამორთულია, ჩვენ ვიღებთ მოსალოდნელ შედეგს - ორი ერთდროულად გაშვებული პროგრამის მეხსიერების მისამართები ემთხვევა.

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

თანმიმდევრულობა

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

განვიხილოთ შემდეგი პროგრამა:

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

მოდით გავუშვათ ეს პროგრამა 1000-იანი არგუმენტით. როგორც თქვენ ალბათ მიხვდით, შედეგი უნდა იყოს 2000, რადგან თითოეული თემა 1000-ჯერ ზრდიდა ცვლადს. თუმცა, ყველაფერი არც ისე მარტივია. მოდით ვცადოთ პროგრამის გაშვება სიდიდის რიგით მეტი გამეორებით.

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

წყარო: www.habr.com