ការណែនាំអំពីប្រព័ន្ធប្រតិបត្តិការ

ហេហេ! ខ្ញុំចង់នាំយកការយកចិត្តទុកដាក់របស់អ្នកនូវស៊េរីនៃអត្ថបទ-ការបកប្រែនៃអក្សរសិល្ប៍គួរឱ្យចាប់អារម្មណ៍មួយនៅក្នុងគំនិតរបស់ខ្ញុំ - OSTEP ។ សម្ភារៈនេះពិភាក្សាយ៉ាងស៊ីជម្រៅអំពីការងាររបស់ប្រព័ន្ធប្រតិបត្តិការដូចយូនីក ពោលគឺធ្វើការជាមួយដំណើរការ កម្មវិធីកំណត់ពេលផ្សេងៗ អង្គចងចាំ និងសមាសធាតុស្រដៀងគ្នាផ្សេងទៀតដែលបង្កើតជាប្រព័ន្ធប្រតិបត្តិការទំនើប។ អ្នកអាចមើលឃើញដើមនៃសម្ភារៈទាំងអស់នៅទីនេះ នៅទីនេះ. សូមចំណាំថាការបកប្រែត្រូវបានធ្វើឡើងដោយគ្មានវិជ្ជាជីវៈ (ដោយសេរី) ប៉ុន្តែខ្ញុំសង្ឃឹមថាខ្ញុំរក្សាបាននូវអត្ថន័យទូទៅ។

ការងារមន្ទីរពិសោធន៍លើប្រធានបទនេះអាចរកបាននៅទីនេះ៖

ផ្នែកផ្សេងទៀត៖

អ្នកក៏អាចពិនិត្យមើលឆានែលរបស់ខ្ញុំនៅ ទូរលេខ =)

ការណែនាំអំពីអ្នករៀបចំកាលវិភាគ

ខ្លឹមសារនៃបញ្ហា៖ របៀបបង្កើតគោលនយោបាយកំណត់ពេល
តើក្របខណ្ឌគោលនយោបាយអ្នកកំណត់ពេលត្រូវបានរចនាឡើងដោយរបៀបណា? តើអ្វីគួរជាការសន្មត់សំខាន់ៗ? តើសូចនាករអ្វីខ្លះដែលសំខាន់? តើបច្ចេកទេសមូលដ្ឋានអ្វីខ្លះដែលត្រូវបានប្រើក្នុងប្រព័ន្ធកុំព្យូទ័រដំបូង?

ការសន្មត់បន្ទុកការងារ

មុននឹងពិភាក្សាអំពីគោលការណ៍ដែលអាចកើតមាន ទីមួយ ចូរយើងធ្វើការវិភាគសាមញ្ញមួយចំនួនអំពីដំណើរការដែលកំពុងដំណើរការនៅក្នុងប្រព័ន្ធ ដែលត្រូវបានគេហៅថាជាសមូហភាព។ បន្ទុកការងារ. ការកំណត់បន្ទុកការងារគឺជាផ្នែកសំខាន់មួយនៃគោលនយោបាយកសាង ហើយនៅពេលដែលអ្នកដឹងកាន់តែច្រើនអំពីបន្ទុកការងារ នោះគោលការណ៍នោះអ្នកអាចសរសេរបានកាន់តែប្រសើរ។

ចូរយើងធ្វើការសន្មត់ខាងក្រោមអំពីដំណើរការដែលកំពុងដំណើរការនៅក្នុងប្រព័ន្ធ ដែលជួនកាលគេហៅថា ការងារ (ភារកិច្ច)។ ស្ទើរតែទាំងអស់នៃការសន្មត់ទាំងនេះមិនមែនជាការពិតទេ ប៉ុន្តែវាចាំបាច់សម្រាប់ការអភិវឌ្ឍន៍ការគិត។

កិច្ចការនីមួយៗដំណើរការក្នុងរយៈពេលដូចគ្នា
ភារកិច្ចទាំងអស់ត្រូវបានកំណត់ក្នុងពេលដំណាលគ្នា,
កិច្ចការដែលបានកំណត់ដំណើរការរហូតដល់ការបញ្ចប់របស់វា
រាល់កិច្ចការទាំងអស់ប្រើតែ CPU,
ពេលវេលាដំណើរការនៃកិច្ចការនីមួយៗត្រូវបានដឹង។

មាត្រដ្ឋានអ្នករៀបចំកាលវិភាគ

បន្ថែមពីលើការសន្មត់មួយចំនួនអំពីបន្ទុក ឧបករណ៍មួយផ្សេងទៀតសម្រាប់ការប្រៀបធៀបគោលការណ៍កំណត់ពេលផ្សេងៗគ្នាគឺត្រូវការ៖ មាត្រដ្ឋានកម្មវិធីកំណត់ពេល។ ម៉ែត្រគឺគ្រាន់តែជារង្វាស់នៃអ្វីមួយប៉ុណ្ណោះ។ មានម៉ែត្រមួយចំនួនដែលអាចត្រូវបានប្រើដើម្បីប្រៀបធៀបអ្នកកំណត់ពេល។

ឧទាហរណ៍យើងនឹងប្រើម៉ែត្រដែលហៅថា ពេលវេលាបង្វិល (ពេលវេលាផ្លាស់ប្តូរ) ។ ពេលវេលាផ្លាស់ប្តូរភារកិច្ចត្រូវបានកំណត់ថាជាភាពខុសគ្នារវាងពេលវេលាបំពេញភារកិច្ច និងពេលវេលាមកដល់កិច្ចការនៅក្នុងប្រព័ន្ធ។

Tturnaround=Tcompletion-Tarrival

ដោយសារយើងសន្មត់ថាកិច្ចការទាំងអស់បានមកដល់ក្នុងពេលតែមួយ នោះ Ta=0 ហើយដូច្នេះ Tt=Tc ។ តម្លៃនេះនឹងផ្លាស់ប្តូរដោយធម្មជាតិនៅពេលដែលយើងផ្លាស់ប្តូរការសន្មត់ខាងលើ។

សូចនាករមួយទៀត - យុត្តិធម៌ (ភាពស្មោះត្រង់ ភាពស្មោះត្រង់)។ ផលិតភាព និងភាពយុត្តិធម៌ជាញឹកញយមានលក្ខណៈផ្ទុយគ្នាក្នុងការធ្វើផែនការ។ ឧទាហរណ៍ កម្មវិធីកំណត់ពេលអាចបង្កើនប្រសិទ្ធភាពប្រតិបត្តិការ ប៉ុន្តែដោយចំណាយលើការរង់ចាំសម្រាប់កិច្ចការផ្សេងទៀតដើម្បីដំណើរការ ដូច្នេះកាត់បន្ថយភាពយុត្តិធម៌។

ជាលើកដំបូងនៅក្នុងការចេញជាលើកដំបូង (FIFO)

ក្បួនដោះស្រាយជាមូលដ្ឋានបំផុតដែលយើងអាចអនុវត្តត្រូវបានគេហៅថា FIFO ឬ មកដំបូង (ចូល) បម្រើដំបូង (ចេញ). ក្បួនដោះស្រាយនេះមានគុណសម្បត្តិជាច្រើន៖ វាងាយស្រួលអនុវត្តណាស់ ហើយវាសមនឹងការសន្មត់របស់យើងទាំងអស់ ហើយបំពេញការងារបានយ៉ាងល្អ។

សូមក្រឡេកមើលឧទាហរណ៍ដ៏សាមញ្ញមួយ។ ឧបមាថាកិច្ចការ 3 ត្រូវបានកំណត់ក្នុងពេលដំណាលគ្នា។ ប៉ុន្តែសូមសន្មតថាកិច្ចការ A បានមកដល់មុនបន្តិចទៀត ដូច្នេះវានឹងបង្ហាញក្នុងបញ្ជីប្រតិបត្តិលឿនជាងកិច្ចការផ្សេងទៀត ដូចជា B ដែលទាក់ទងនឹង C។ ចូរសន្មតថាកិច្ចការនីមួយៗនឹងត្រូវបានប្រតិបត្តិរយៈពេល 10 វិនាទី។ តើពេលវេលាជាមធ្យមនឹងទៅជាយ៉ាងណាដើម្បីបញ្ចប់កិច្ចការទាំងនេះក្នុងករណីនេះ?

ដោយការរាប់តម្លៃ - 10+20+30 និងចែកដោយ 3 យើងទទួលបានពេលវេលាប្រតិបត្តិកម្មវិធីជាមធ្យមស្មើនឹង 20 វិនាទី។
ឥឡូវនេះ ចូរយើងព្យាយាមផ្លាស់ប្តូរការសន្មត់របស់យើង។ ជាពិសេស ការសន្មត់ទី 1 ហើយដូច្នេះ យើងនឹងលែងសន្មត់ថា កិច្ចការនីមួយៗត្រូវចំណាយពេលវេលាដូចគ្នាដើម្បីប្រតិបត្តិ។ តើ FIFO នឹងធ្វើយ៉ាងណានៅពេលនេះ?

ដូចដែលវាប្រែចេញ ពេលវេលានៃការអនុវត្តភារកិច្ចផ្សេងៗគ្នាមានផលប៉ះពាល់អវិជ្ជមានយ៉ាងខ្លាំងទៅលើផលិតភាពនៃក្បួនដោះស្រាយ FIFO ។ ចូរសន្មតថាកិច្ចការ A នឹងចំណាយពេល 100 វិនាទីដើម្បីបញ្ចប់ ខណៈពេលដែល B និង C នឹងនៅតែចំណាយពេល 10 វិនាទីនីមួយៗ។

ដូចដែលអាចមើលឃើញពីតួលេខ ពេលវេលាជាមធ្យមសម្រាប់ប្រព័ន្ធនឹងមាន (100+110+120)/3=110។ ឥទ្ធិពលនេះត្រូវបានគេហៅថា ឥទ្ធិពលនៃក្បួននៅពេលដែលអ្នកប្រើប្រាស់រយៈពេលខ្លីមួយចំនួននៃធនធាននឹងតម្រង់ជួរបន្ទាប់ពីអ្នកប្រើប្រាស់ធ្ងន់។ វាដូចជាបន្ទាត់នៅហាងលក់គ្រឿងទេស នៅពេលដែលមានអតិថិជននៅពីមុខអ្នកជាមួយនឹងរទេះពេញ។ ដំណោះស្រាយដ៏ល្អបំផុតចំពោះបញ្ហាគឺ ព្យាយាមផ្លាស់ប្តូរការចុះឈ្មោះសាច់ប្រាក់ ឬសម្រាក និងដកដង្ហើមឱ្យជ្រៅ។

ការងារខ្លីបំផុតដំបូង

តើវាអាចទៅរួចទេក្នុងការដោះស្រាយស្ថានភាពស្រដៀងគ្នាជាមួយនឹងដំណើរការទម្ងន់ធ្ងន់? ពិតប្រាកដ។ ប្រភេទនៃផែនការមួយទៀតត្រូវបានគេហៅថាការងារខ្លីបំផុតដំបូង (SJF) ។ ក្បួនដោះស្រាយរបស់វាក៏មានលក្ខណៈបឋមផងដែរ - ដូចដែលឈ្មោះបង្កប់ន័យ កិច្ចការខ្លីបំផុតនឹងត្រូវបានដាក់ឱ្យដំណើរការជាដំបូង មួយបន្ទាប់ពីមួយផ្សេងទៀត។

ក្នុងឧទាហរណ៍នេះ លទ្ធផលនៃការដំណើរការដំណើរការដូចគ្នានឹងមានភាពប្រសើរឡើងនៅក្នុងរយៈពេលនៃការផ្លាស់ប្តូរកម្មវិធីជាមធ្យម ហើយវានឹងស្មើនឹង 50 ជំនួសឱ្យ 110ដែលល្អជាងជិត២ដង។

ដូច្នេះ សម្រាប់ការសន្មត់ថាកិច្ចការទាំងអស់មកដល់ក្នុងពេលដំណាលគ្នានោះ ក្បួនដោះស្រាយ SJF ហាក់បីដូចជាជាក្បួនដោះស្រាយដ៏ល្អប្រសើរបំផុត។ ទោះយ៉ាងណាក៏ដោយ ការសន្មត់របស់យើងនៅតែហាក់ដូចជាមិនប្រាកដ។ លើកនេះយើងផ្លាស់ប្តូរការសន្មត់ទី 2 ហើយលើកនេះស្រមៃថាកិច្ចការអាចមានវត្តមាននៅពេលណាមួយ ហើយមិនមែនទាំងអស់ក្នុងពេលតែមួយនោះទេ។ តើនេះអាចនាំឱ្យមានបញ្ហាអ្វីខ្លះ?

ចូរយើងស្រមៃថាកិច្ចការ A (100c) មកដល់មុនគេ ហើយចាប់ផ្តើមត្រូវបានអនុវត្ត។ នៅ t=10 កិច្ចការ B និង C មកដល់ ដែលនីមួយៗនឹងចំណាយពេល 10 វិនាទី។ ដូច្នេះ ពេលវេលាប្រតិបត្តិជាមធ្យមគឺ (100+(110-10)+(120-10))3 = 103។ តើកម្មវិធីកំណត់ពេលអាចធ្វើអ្វីដើម្បីកែលម្អវា?

រយៈពេលខ្លីបំផុតដើម្បីបញ្ចប់ដំបូង (STCF)

ដើម្បីធ្វើឱ្យស្ថានការណ៍ប្រសើរឡើង យើងលុបចោលការសន្មត់ទី 3 ដែលកម្មវិធីត្រូវបានចាប់ផ្តើម និងដំណើរការរហូតដល់ការបញ្ចប់។ លើសពីនេះទៀត យើងនឹងត្រូវការជំនួយផ្នែករឹង ហើយដូចដែលអ្នកប្រហែលជាទាយ យើងនឹងប្រើ កម្មវិធីកំណត់ពេលវេលា ដើម្បីរំខានកិច្ចការដែលកំពុងដំណើរការ និង ការផ្លាស់ប្តូរបរិបទ. ដូច្នេះ អ្នកកំណត់ពេលអាចធ្វើអ្វីមួយនៅពេលកិច្ចការ B, C មកដល់ - បញ្ឈប់ការប្រតិបត្តិកិច្ចការ A ហើយដាក់កិច្ចការ B និង C ឱ្យដំណើរការ ហើយបន្ទាប់ពីពួកគេបានបញ្ចប់ បន្តដំណើរការ A. កម្មវិធីកំណត់ពេលបែបនេះត្រូវបានគេហៅថា STCFឬ ការងារមុនគេ.

លទ្ធផលនៃអ្នករៀបចំផែនការនេះនឹងមានលទ្ធផលដូចខាងក្រោម៖ ((120-0)+(20-10)+(30-10))/3=50។ ដូច្នេះ កម្មវិធីកំណត់ពេលបែបនេះកាន់តែល្អសម្រាប់កិច្ចការរបស់យើង។

ពេលវេលាឆ្លើយតបម៉ែត្រ

ដូច្នេះប្រសិនបើយើងដឹងពីពេលវេលាដំណើរការនៃកិច្ចការ ហើយថាកិច្ចការទាំងនេះប្រើតែ CPU នោះ STCF នឹងក្លាយជាដំណោះស្រាយដ៏ល្អបំផុត។ ហើយនៅពេលដំបូង ក្បួនដោះស្រាយទាំងនេះដំណើរការបានល្អ។ ទោះជាយ៉ាងណាក៏ដោយ ឥឡូវនេះអ្នកប្រើប្រាស់ចំណាយពេលភាគច្រើនរបស់នាងនៅឯស្ថានីយ ហើយរំពឹងថានឹងទទួលបានបទពិសោធន៍អន្តរកម្មប្រកបដោយផលិតភាព។ ដូច្នេះម៉ែត្រថ្មីមួយបានកើត - ពេលវេលាឆ្លើយតប (ការឆ្លើយតប) ។

ពេលវេលាឆ្លើយតបត្រូវបានគណនាដូចខាងក្រោមៈ

Tresponse=Tfistrrun-Tarrival

ដូច្នេះសម្រាប់ឧទាហរណ៍មុន ពេលវេលាឆ្លើយតបនឹងមានៈ A=0, B=0, C=10 (abg=3,33)។

ហើយវាប្រែថាក្បួនដោះស្រាយ STCF មិនសូវល្អទេក្នុងស្ថានភាពដែលកិច្ចការ 3 មកដល់ក្នុងពេលតែមួយ - វានឹងត្រូវរង់ចាំរហូតដល់កិច្ចការតូចៗត្រូវបានបញ្ចប់ទាំងស្រុង។ ដូច្នេះក្បួនដោះស្រាយគឺល្អសម្រាប់ម៉ែត្រវេនវេន ប៉ុន្តែអាក្រក់សម្រាប់ម៉ែត្រអន្តរកម្ម។ ស្រមៃមើលថាតើអ្នកកំពុងអង្គុយនៅស្ថានីយព្យាយាមវាយតួអក្សរទៅក្នុងកម្មវិធីនិពន្ធ ហើយត្រូវរង់ចាំលើសពី 10 វិនាទី ដោយសារកិច្ចការផ្សេងទៀតកំពុងដំណើរការស៊ីភីយូ។ វាមិនរីករាយខ្លាំងណាស់។

ដូច្នេះយើងត្រូវប្រឈមមុខនឹងបញ្ហាមួយទៀត - តើយើងអាចបង្កើតកម្មវិធីកំណត់ពេលវេលាដែលងាយនឹងឆ្លើយតបដោយរបៀបណា?

រ៉ូប៊ីនមូល

ក្បួនដោះស្រាយមួយត្រូវបានបង្កើតឡើងដើម្បីដោះស្រាយបញ្ហានេះ។ រ៉ូប៊ីនមូល (RR) ។ គំនិតជាមូលដ្ឋានគឺសាមញ្ញណាស់៖ ជំនួសឱ្យការដំណើរការភារកិច្ចរហូតដល់ពួកគេបានបញ្ចប់ យើងនឹងដំណើរការភារកិច្ចក្នុងរយៈពេលជាក់លាក់មួយ (ហៅថាពេលវេលាមួយ) ហើយបន្ទាប់មកប្តូរទៅកិច្ចការផ្សេងទៀតពីជួរ។ ក្បួនដោះស្រាយដំណើរការឡើងវិញរហូតដល់កិច្ចការទាំងអស់ត្រូវបានបញ្ចប់។ ក្នុងករណីនេះ ពេលវេលាដំណើរការនៃកម្មវិធីត្រូវតែជាពហុពេលវេលា បន្ទាប់ពីនោះកម្មវិធីកំណត់ម៉ោងនឹងរំខានដំណើរការ។ ឧទាហរណ៍ ប្រសិនបើកម្មវិធីកំណត់ម៉ោងរំខានដំណើរការរាល់ x=10ms នោះទំហំនៃបង្អួចប្រតិបត្តិដំណើរការគួរតែជាពហុគុណនៃ 10 ហើយជា 10,20 ឬ x*10។

សូមក្រឡេកមើលឧទាហរណ៍៖ កិច្ចការ ABC មកដល់ក្នុងពេលដំណាលគ្នានៅក្នុងប្រព័ន្ធ ហើយពួកគេម្នាក់ៗចង់ដំណើរការរយៈពេល 5 វិនាទី។ ក្បួនដោះស្រាយ SJF នឹងបំពេញកិច្ចការនីមួយៗ មុនពេលចាប់ផ្តើមការងារផ្សេងទៀត។ ផ្ទុយទៅវិញ ក្បួនដោះស្រាយ RR ដែលមានបង្អួចបើកដំណើរការ = 1s នឹងឆ្លងកាត់កិច្ចការដូចខាងក្រោម (រូបភាព 4.3)៖

(SJF ម្តងទៀត (មិនល្អសម្រាប់ពេលវេលាឆ្លើយតប)

(ជុំ Robin (ល្អសម្រាប់ពេលវេលាឆ្លើយតប)

ពេលវេលាឆ្លើយតបជាមធ្យមសម្រាប់ក្បួនដោះស្រាយ RR គឺ (0+1+2)/3=1 ខណៈពេលដែលសម្រាប់ SJF (0+5+10)/3=5។

វាជាឡូជីខលក្នុងការសន្មត់ថាបង្អួចពេលវេលាគឺជាប៉ារ៉ាម៉ែត្រសំខាន់សម្រាប់ RR កាន់តែតូច ពេលវេលាឆ្លើយតបកាន់តែខ្ពស់។ ទោះជាយ៉ាងណាក៏ដោយ អ្នកមិនគួរធ្វើឱ្យវាតូចពេកទេ ព្រោះពេលវេលាផ្លាស់ប្តូរបរិបទក៏នឹងដើរតួក្នុងដំណើរការទាំងមូលផងដែរ។ ដូច្នេះជម្រើសនៃពេលវេលាដំណើរការបង្អួចត្រូវបានកំណត់ដោយស្ថាបត្យករ OS និងអាស្រ័យលើភារកិច្ចដែលត្រូវបានគ្រោងនឹងប្រតិបត្តិនៅក្នុងវា។ ការប្តូរបរិបទមិនមែនជាប្រតិបត្តិការសេវាកម្មតែមួយគត់ដែលខ្ជះខ្ជាយពេលវេលានោះទេ - កម្មវិធីដែលកំពុងដំណើរការដំណើរការលើអ្វីៗផ្សេងទៀតជាច្រើន ឧទាហរណ៍ ឃ្លាំងសម្ងាត់ផ្សេងៗ ហើយជាមួយនឹងការប្តូរនីមួយៗ វាចាំបាច់ក្នុងការរក្សាទុក និងស្តារបរិស្ថាននេះឡើងវិញ ដែលអាចប្រើប្រាស់បានច្រើនផងដែរ។ ពេលវេលា។

RR គឺជាកម្មវិធីកំណត់ពេលដ៏ល្អមួយ ប្រសិនបើយើងនិយាយតែអំពីរង្វាស់ពេលវេលាឆ្លើយតបប៉ុណ្ណោះ។ ប៉ុន្តែតើម៉ែត្រវិលជុំនៃពេលវេលានឹងប្រព្រឹត្តទៅតាមក្បួនដោះស្រាយនេះដោយរបៀបណា? ពិចារណាឧទាហរណ៍ខាងលើនៅពេលដែលពេលវេលាប្រតិបត្តិការ A, B, C = 5s និងមកដល់ក្នុងពេលតែមួយ។ កិច្ចការ A នឹងបញ្ចប់នៅ 13, B នៅ 14, C នៅ 15s ហើយពេលវេលាផ្លាស់ប្តូរជាមធ្យមនឹងមាន 14s។ ដូច្នេះ RR គឺជាក្បួនដោះស្រាយដ៏អាក្រក់បំផុតសម្រាប់រង្វាស់រង្វិល។

នៅក្នុងពាក្យទូទៅជាងនេះ ក្បួនដោះស្រាយប្រភេទ RR ណាមួយគឺមានភាពយុត្តិធម៌ វាបែងចែកពេលវេលាស៊ីភីយូស្មើគ្នារវាងដំណើរការទាំងអស់។ ដូច្នេះហើយ មាត្រដ្ឋានទាំងនេះតែងតែប៉ះទង្គិចគ្នាទៅវិញទៅមក។

ដូច្នេះហើយ យើងមានក្បួនដោះស្រាយផ្ទុយគ្នាជាច្រើន ហើយក្នុងពេលជាមួយគ្នានេះ វានៅតែមានការសន្មត់ជាច្រើនដែលនៅសល់ - ថាពេលវេលានៃកិច្ចការត្រូវបានដឹង ហើយថាកិច្ចការនោះប្រើតែស៊ីភីយូប៉ុណ្ណោះ។

លាយជាមួយ I/O

ជាដំបូង យើងដកការសន្មត់ទី 4 ដែលដំណើរការនេះប្រើតែ CPU ប៉ុណ្ណោះ ជាធម្មតា នេះមិនមែនជាករណីទេ ហើយដំណើរការអាចចូលប្រើឧបករណ៍ផ្សេងទៀត។

នៅពេលដែលដំណើរការណាមួយស្នើសុំប្រតិបត្តិការ I/O ដំណើរការចូលទៅក្នុងស្ថានភាពដែលត្រូវបានរារាំង ដោយរង់ចាំ I/O បញ្ចប់។ ប្រសិនបើ I/O ត្រូវបានផ្ញើទៅកាន់ hard drive នោះប្រតិបត្តិការបែបនេះអាចចំណាយពេលច្រើន ms ឬយូរជាងនេះ ហើយ processor នឹងនៅទំនេរនៅពេលនេះ។ ក្នុងអំឡុងពេលនេះ កម្មវិធីកំណត់ពេលអាចកាន់កាប់ខួរក្បាលជាមួយនឹងដំណើរការផ្សេងទៀតណាមួយ។ ការសម្រេចចិត្តបន្ទាប់ដែលអ្នកកំណត់ពេលនឹងត្រូវធ្វើគឺនៅពេលដែលដំណើរការនេះនឹងបញ្ចប់ I/O របស់ខ្លួន។ នៅពេលដែលវាកើតឡើង ការរំខាននឹងកើតឡើង ហើយ OS នឹងដាក់ដំណើរការដែលហៅថា I/O ចូលទៅក្នុងស្ថានភាពរួចរាល់។

សូមក្រឡេកមើលឧទាហរណ៍នៃកិច្ចការជាច្រើន។ ពួកគេម្នាក់ៗត្រូវការពេលវេលាស៊ីភីយូ 50ms ។ ទោះយ៉ាងណាក៏ដោយ ទីមួយនឹងចូលប្រើ I/O រៀងរាល់ 10ms (ដែលនឹងត្រូវប្រតិបត្តិរាល់ 10ms)។ ហើយដំណើរការ B ប្រើប្រព័ន្ធដំណើរការ 50ms ដោយគ្មាន I/O ។

ក្នុងឧទាហរណ៍នេះ យើងនឹងប្រើកម្មវិធីកំណត់ពេល STCF ។ តើកម្មវិធីកំណត់ពេលនឹងមានឥរិយាបទដូចម្តេច ប្រសិនបើដំណើរការដូច A ត្រូវបានចាប់ផ្តើមនៅលើវា? គាត់នឹងធ្វើដូចខាងក្រោម៖ ដំបូងគាត់នឹងដំណើរការទាំងស្រុងនូវដំណើរការ A ហើយបន្ទាប់មកដំណើរការ B ។

វិធីសាស្រ្តបែបប្រពៃណីដើម្បីដោះស្រាយបញ្ហានេះគឺដើម្បីចាត់ចែងកិច្ចការរង 10 ms នៃដំណើរការ A ជាកិច្ចការដាច់ដោយឡែកមួយ។ ដូច្នេះនៅពេលចាប់ផ្តើមជាមួយក្បួនដោះស្រាយ STJF ជម្រើសរវាងកិច្ចការ 50 ms និងកិច្ចការ 10 ms គឺជាក់ស្តែង។ បន្ទាប់មក នៅពេលដែលកិច្ចការរង A ត្រូវបានបញ្ចប់ ដំណើរការ B និង I/O នឹងត្រូវបានដាក់ឱ្យដំណើរការ។ បន្ទាប់ពី I/O បានបញ្ចប់ វានឹងក្លាយជាទម្លាប់ក្នុងការចាប់ផ្តើមដំណើរការ 10ms A ម្តងទៀតជំនួសឱ្យដំណើរការ B។ តាមរបៀបនេះ វាអាចអនុវត្តការត្រួតគ្នា ដែលស៊ីភីយូត្រូវបានប្រើប្រាស់ដោយដំណើរការផ្សេងទៀត ខណៈពេលដែលដំណើរការទីមួយកំពុងរង់ចាំ អាយ/អូ។ ហើយជាលទ្ធផល ប្រព័ន្ធត្រូវបានប្រើប្រាស់កាន់តែប្រសើរ - នៅពេលដំណើរការអន្តរកម្មកំពុងរង់ចាំ I/O ដំណើរការផ្សេងទៀតអាចត្រូវបានប្រតិបត្តិនៅលើខួរក្បាល។

Oracle លែងមានទៀតហើយ

ឥឡូវនេះសូមព្យាយាមកម្ចាត់ការសន្មត់ថាពេលវេលាដំណើរការនៃភារកិច្ចត្រូវបានដឹង។ ជាទូទៅនេះគឺជាការសន្មត់ដ៏អាក្រក់បំផុត និងមិនប្រាកដប្រជាបំផុតនៅក្នុងបញ្ជីទាំងមូល។ តាមពិតនៅក្នុង OS ធម្មតាជាមធ្យម OS ខ្លួនវាជាធម្មតាដឹងតិចតួចណាស់អំពីពេលវេលាប្រតិបត្តិនៃភារកិច្ច ដូច្នេះតើអ្នកអាចបង្កើតកម្មវិធីកំណត់ពេលដោយមិនដឹងថាត្រូវចំណាយពេលប៉ុន្មានដើម្បីប្រតិបត្តិ? ប្រហែលជាយើងអាចប្រើគោលការណ៍ RR មួយចំនួនដើម្បីដោះស្រាយបញ្ហានេះ?

លទ្ធផល

យើងបានក្រឡេកមើលគំនិតជាមូលដ្ឋាននៃការរៀបចំកាលវិភាគការងារ និងមើលទៅលើគ្រួសារ 2 នៃអ្នករៀបចំកាលវិភាគ។ ទីមួយចាប់ផ្តើមកិច្ចការខ្លីបំផុតជាមុនសិន ហើយដូច្នេះបង្កើនពេលវេលាផ្លាស់ប្តូរ ចំណែកទីពីរត្រូវរហែករវាងកិច្ចការទាំងអស់ស្មើគ្នា បង្កើនពេលវេលាឆ្លើយតប។ ក្បួនដោះស្រាយទាំងពីរគឺមិនល្អ ដែលក្បួនដោះស្រាយនៃគ្រួសារផ្សេងទៀតគឺល្អ។ យើងក៏បានក្រឡេកមើលពីរបៀបដែលការប្រើប្រាស់ស៊ីភីយូ និង I/O ស្របគ្នាអាចធ្វើអោយដំណើរការប្រសើរឡើង ប៉ុន្តែមិនបានដោះស្រាយបញ្ហាជាមួយ OS clairvoyance នោះទេ។ ហើយនៅក្នុងមេរៀនបន្ទាប់ យើងនឹងពិនិត្យមើលអ្នករៀបចំផែនការដែលមើលទៅអតីតកាលភ្លាមៗ ហើយព្យាយាមទស្សន៍ទាយអនាគត។ ហើយវាត្រូវបានគេហៅថាជួរមតិកែលម្អច្រើនកម្រិត។

ប្រភព: www.habr.com

ប្រព័ន្ធប្រតិបត្តិការ៖ បីផ្នែកងាយស្រួល។ ផ្នែកទី 4: ការណែនាំអំពីកម្មវិធីកំណត់ពេល (ការបកប្រែ)