Real-time na operating system

Isang operating system na maaaring magbigay ng kinakailangang oras ng pagpapatupad para sa isang real-time na gawain kahit na sa pinakamasamang kaso, tinawag mahirap real-time na operating system.

Isang operating system na maaaring magbigay ng kinakailangang oras ng pagpapatupad para sa isang real-time na gawain sa karaniwan, tinawag malambot na real-time na operating system.

Hindi pinapayagan ng mga hard real-time na system ang mga pagkaantala sa pagtugon ng system, dahil maaari itong humantong sa:

• pagkawala ng kaugnayan ng mga resulta
• malaking pagkalugi sa pananalapi
• aksidente at sakuna

Kung ang kritikal na pagpoproseso ay hindi magaganap o hindi magaganap nang mabilis, ang mahirap na real-time na sistema ay iaabort ang operasyon at hinaharangan ito upang ang pagiging maaasahan at kakayahang magamit ng natitirang bahagi ng system ay hindi maapektuhan. Ang mga halimbawa ng mga hard real-time system ay maaaring - on-board system kontrol (sa isang eroplano, spacecraft, barko, atbp.), mga sistema ng proteksyong pang-emergency, mga recorder ng kaganapang pang-emergency.

Ang mga malalambot na real-time na system ay nailalarawan sa pamamagitan ng posibilidad ng pagkaantala ng pagtugon, na maaaring humantong sa pagtaas ng gastos ng mga resulta at pagbawas sa pagganap ng system sa kabuuan. Ang isang halimbawa ay ang pagpapatakbo ng isang computer network. Kung ang system ay walang oras upang iproseso ang susunod tinanggap na pakete, magdudulot ito ng paghinto at muling pagpapadala ng panig ng pagpapadala (depende sa protocol). Walang nawawalang data, ngunit nabawasan ang pagganap ng network.

Ang pangunahing pagkakaiba sa pagitan ng mahirap at malambot na real-time na mga system ay maaaring ilarawan bilang mga sumusunod: ang isang mahirap na real-time na system ay hindi kailanman mahuhuli sa pagtugon sa isang kaganapan, habang ang isang malambot na real-time na sistema ay hindi dapat huli sa pagtugon sa isang kaganapan.

Ipahiwatig natin sa pamamagitan ng isang real-time na operating system ang isang system na maaaring magamit upang bumuo ng mga hard real-time na system. Ang kahulugan na ito ay nagpapahayag ng saloobin patungo sa isang RTOS bilang isang bagay na naglalaman mga kinakailangang kasangkapan, ngunit nangangahulugan din na ang mga tool na ito ay kailangan pa ring gamitin nang tama.

Karamihan sa software ay nakatuon sa "malambot" totoong oras. Ang ganitong mga sistema ay nailalarawan sa pamamagitan ng:

• garantisadong oras ng pagtugon sa mga panlabas na kaganapan (mga pagkagambala mula sa kagamitan);
• isang matibay na subsystem sa pagpaplano ng proseso (ang mga gawaing may mataas na priyoridad ay hindi dapat palitan ng mga gawaing mababa ang priyoridad, na may ilang mga eksepsiyon);
• mas mataas na mga kinakailangan para sa oras ng pagtugon sa mga panlabas na kaganapan o reaktibidad (ang pagkaantala sa pagtawag sa isang interrupt na handler ay hindi hihigit sa sampu-sampung microseconds, pagkaantala kapag ang paglipat ng mga gawain ay hindi hihigit sa daan-daang microseconds)

Ang isang klasikong halimbawa ng isang gawain kung saan kinakailangan ang isang RTOS ay ang kontrol ng isang robot na kumukuha ng isang bahagi mula sa isang conveyor belt. Ang bahagi ay gumagalaw, at ang robot ay mayroon lamang isang maliit na window ng oras kapag ito ay maaaring kunin ito. Kung siya ay huli, kung gayon ang bahagi ay wala na sa nais na seksyon ng conveyor, at samakatuwid ang gawain ay hindi makukumpleto, sa kabila ng katotohanan na ang robot ay nasa tamang lugar. Kung siya ay naghahanda nang mas maaga, ang bahagi ay hindi magkakaroon ng oras upang makarating, at haharangin niya ang landas nito.

Mga natatanging tampok ng RTOS

Talahanayan ng paghahambing sa pagitan ng RTOS at maginoo na operating system:

Mga arkitekturang RTOS

Sa kanilang pag-unlad, ang mga RTOS ay itinayo batay sa mga sumusunod na arkitektura.

• . Ang OS ay tinukoy bilang isang hanay ng mga module na nakikipag-ugnayan sa isa't isa sa loob ng kernel ng system at nagbibigay ng software ng application mga interface ng input para sa mga tawag sa kagamitan. Ang pangunahing kawalan ng prinsipyong ito ng pagbuo ng isang OS ay ang mahinang predictability ng pag-uugali nito na sanhi ng kumplikadong pakikipag-ugnayan ng mga module sa bawat isa.
• . Ang software ng application ay may kakayahang ma-access ang hardware hindi lamang sa pamamagitan ng kernel ng system at mga serbisyo nito, ngunit direkta din. Kung ikukumpara sa isang monolitikong arkitektura, ang ganitong arkitektura ay nagbibigay ng mas malaking antas ng predictability ng mga reaksyon ng system, at nagbibigay-daan din para sa mabilis na pag-access mga aplikasyon ng aplikasyon sa kagamitan. Ang pangunahing kawalan ng naturang mga sistema ay ang kakulangan ng multitasking.
• Arkitektura ng Client-server. Ang pangunahing prinsipyo nito ay upang dalhin ang mga serbisyo ng OS sa anyo ng mga server sa antas ng gumagamit at isagawa ang mga microkernel function ng isang message manager sa pagitan ng kliyente mga programa ng gumagamit at mga server - mga serbisyo ng system. Ang mga pakinabang ng arkitektura na ito:

1. Tumaas na pagiging maaasahan, dahil ang bawat serbisyo ay, sa katunayan, isang independiyenteng aplikasyon at mas madaling i-debug at subaybayan ang mga error;
2. Pinahusay na scalability, dahil ang mga hindi kinakailangang serbisyo ay maaaring ibukod mula sa system nang hindi nakompromiso ang pagganap nito;
3. Tumaas na fault tolerance, dahil ang isang nakapirming serbisyo ay maaaring i-restart nang hindi nire-reboot ang system.

Mga Tampok ng Kernel

Tinitiyak ng kernel ng RTOS ang paggana ng isang intermediate abstract OS level, na nagtatago ng mga detalye mula sa application software teknikal na aparato processor (maraming processor) at nauugnay na hardware.

Mga pangunahing serbisyo

Ang abstract layer na ito ay nagbibigay ng limang pangunahing kategorya ng mga serbisyo para sa application software.

• Pamamahala ng gawain. Ang pinaka pangunahing pangkat serbisyo. Nagbibigay-daan sa mga developer ng application na magdisenyo ng mga produkto ng software bilang mga hanay ng mga hiwalay na fragment ng program, na ang bawat isa ay maaaring nauugnay sa sarili nitong lugar ng paksa, magsagawa ng hiwalay na function at may sariling time slice na inilaan dito para sa trabaho. Ang bawat naturang fragment ay tinatawag gawain. Ang mga serbisyo sa pangkat na ito ay may kakayahang maglunsad ng mga gawain at magtalaga ng mga priyoridad sa kanila. Ang pangunahing serbisyo dito ay tagapag-iskedyul ng gawain. Sinusubaybayan nito ang pagpapatupad ng mga kasalukuyang gawain, naglulunsad ng mga bago sa naaangkop na tagal ng panahon at sinusubaybayan ang kanilang mode ng operasyon.
• Dynamic na Memory Allocation. Marami (ngunit hindi lahat) na mga kernel ng RTOS ang sumusuporta sa grupong ito ng mga serbisyo. Pinapayagan nito ang mga gawain na humiram ng mga bahagi ng RAM para sa pansamantalang paggamit sa pagpapatakbo ng mga application. Kadalasan ang mga lugar na ito ay lumilipat sa iba't ibang gawain, at sa pamamagitan nito mabilis na paglipat maraming data sa pagitan nila. Ang ilang napakaliit na kernel ng RTOS na nilalayong gamitin sa mga kapaligiran ng hardware na may mahigpit na limitasyon sa memorya ay hindi sumusuporta sa mga serbisyo ng dynamic na paglalaan ng memorya.
• Pamamahala ng timer. Dahil ang mga naka-embed na system ay may mahigpit na kinakailangan para sa time frame para sa pagpapatupad ng gawain, ang RTOS core ay kinabibilangan ng isang pangkat ng mga serbisyo na nagbibigay ng pamamahala ng timer upang subaybayan ang limitasyon ng oras kung kailan dapat isagawa ang isang gawain. Ang mga serbisyong ito ay sumusukat at nagtatakda ng iba't ibang agwat ng oras (mula sa 1 μs pataas), bumubuo ng mga interrupt kapag nag-expire ang mga agwat ng oras, at lumikha ng isang beses at paikot na mga alarma.
• Inter-task communication at synchronization. Ang mga serbisyo sa pangkat na ito ay nagpapahintulot sa mga gawain na makipagpalitan ng impormasyon at matiyak ang kaligtasan nito. Pinapagana din nila ang mga fragment ng software na i-coordinate ang kanilang trabaho sa isa't isa upang mapataas ang kahusayan. Kung ang mga serbisyong ito ay hindi kasama sa RTOS core, ang mga gawain ay magsisimulang makipagpalitan ng pangit na impormasyon at maaaring makagambala sa gawain ng mga kalapit na gawain.
• Pagsubaybay sa I/O device. Nagbibigay ang mga serbisyo sa pangkat na ito ng isang interface ng software na nakikipag-ugnayan sa maraming driver ng device na karaniwan sa karamihan ng mga naka-embed na system.

Bilang karagdagan sa mga serbisyo ng kernel, maraming RTOS ang nag-aalok ng mga linya karagdagang mga bahagi upang ayusin ang mga konseptong may mataas na antas tulad ng file system, networking, pamamahala ng network, pamamahala ng database, graphical user interface, atbp. Bagama't marami sa mga bahaging ito ay mas malaki at mas kumplikado kaysa sa RTOS core mismo, gayunpaman ay umaasa sila sa mga serbisyo nito. Ang bawat isa sa mga bahaging ito ay kasama sa naka-embed na sistema lamang kung ang mga serbisyo nito ay kinakailangan upang maisakatuparan ang naka-embed na aplikasyon at para lamang mabawasan ang pagkonsumo ng memorya sa pinakamababa.

Mga pagkakaiba mula sa pangkalahatang layunin na mga operating system

Sinusuportahan din ng maraming pangkalahatang layunin na operating system ang mga serbisyo sa itaas. Gayunpaman, ang pangunahing pagkakaiba sa pagitan ng mga pangunahing serbisyo ng RTOS ay deterministiko, batay sa mahigpit na kontrol sa oras, ang likas na katangian ng kanilang trabaho. SA sa kasong ito Sa pamamagitan ng determinismo, ibig sabihin namin na ang pagpapatupad ng isang serbisyo ng operating system ay nangangailangan ng agwat ng oras ng isang kilalang tagal. Sa teorya, ang oras na ito ay maaaring kalkulahin gamit ang mga mathematical formula, na dapat ay mahigpit na algebraic at hindi dapat magsama ng anumang mga parameter ng oras na random na kalikasan. Anumang random na variable na tumutukoy sa oras ng pagpapatupad ng isang gawain sa isang RTOS ay maaaring magdulot ng hindi gustong pagkaantala sa aplikasyon, at ang susunod na gawain ay hindi makakatugon sa time slice nito, na magdudulot ng error.

Sa ganitong kahulugan, ang pangkalahatang layunin ng mga operating system ay hindi deterministiko. Maaaring payagan ng kanilang mga serbisyo ang mga paminsan-minsang pagkaantala sa kanilang operasyon, na maaaring humantong sa pagbagal sa pagtugon ng application sa mga pagkilos ng user sa hindi kilalang oras. Kapag nagdidisenyo ng mga maginoo na operating system, hindi itinuon ng mga developer ang kanilang pansin sa mathematical apparatus para sa pagkalkula ng oras ng pagpapatupad tiyak na gawain at serbisyo. Hindi ito kritikal para sa ganitong uri ng sistema.

Pag-iiskedyul ng mga gawain

Trabaho ng scheduler

Karamihan sa RTOS ay nagsasagawa ng pag-iiskedyul ng gawain gamit ang sumusunod na scheme. Ang bawat gawain sa application ay itinalaga ng isang tiyak na priyoridad. Kung mas mataas ang priyoridad, mas mataas dapat ang reaktibiti ng gawain. Ang mataas na reaktibiti ay nakakamit sa pamamagitan ng pagpapatupad ng diskarte priority preemptive scheduling(preemptive scheduling), ang kakanyahan nito ay pinahihintulutan ang scheduler na ihinto ang pagpapatupad ng anumang gawain sa isang di-makatwirang punto sa oras kung natukoy na ang isa pang gawain ay dapat na magsimula kaagad.

Ang inilarawan na pamamaraan ay gumagana ayon sa sumusunod na panuntunan: kung ang dalawang gawain ay handa nang tumakbo sa parehong oras, ngunit ang una ay may mataas na priyoridad at ang pangalawa ay may mababang priyoridad, kung gayon ang scheduler ay magbibigay ng kagustuhan sa una. Ang pangalawang gawain ay ilulunsad lamang pagkatapos makumpleto ng una ang gawain nito.

Posible na ang isang mababang priyoridad na gawain ay tumatakbo na, at ang scheduler ay nakatanggap ng isang mensahe na ang isa pang mas mataas na priyoridad na gawain ay handa nang tumakbo. Ang dahilan nito ay maaaring ilang panlabas na impluwensya (pagkagambala mula sa kagamitan), tulad ng pagbabago sa estado ng switch ng isang device na kinokontrol ng isang RTOS. Sa ganoong sitwasyon, kikilos ang tagapag-iskedyul ng gawain ayon sa priority preemptive scheduling approach gaya ng mga sumusunod. Ang isang gawain na may mababang priyoridad ay papayagang kumpletuhin ang kasalukuyang utos ng pagpupulong (ngunit hindi ang utos na inilarawan sa source code ng programa sa isang mataas na antas ng wika), pagkatapos nito ay hihinto ang pagsasagawa ng gawain. Susunod, inilunsad ang isang mataas na priyoridad na gawain. Matapos itong maproseso, sisimulan ng scheduler ang naantala na unang gawain sa pagtuturo ng pagpupulong kasunod ng huling naisakatuparan.

Sa tuwing makakatanggap ang scheduler ng gawain ng senyales tungkol sa paglitaw ng ilang panlabas na kaganapan (trigger), ang sanhi nito ay maaaring alinman sa hardware o software, ito ay kumikilos ayon sa sumusunod na algorithm.

1. Tinutukoy kung ang kasalukuyang tumatakbong gawain ay dapat magpatuloy sa pagtakbo.
2. Itinatakda kung aling gawain ang susunod na dapat tumakbo.
3. Sine-save ang konteksto ng isang nahintong gawain (upang maipagpatuloy nito ang trabaho mula sa kung saan ito itinigil)
4. Itinatakda ang konteksto para sa susunod na gawain.
5. Pinapatakbo ang gawaing ito.

Ang limang hakbang na ito ng algorithm ay tinatawag din pagpapalit ng mga gawain.

Pagpapatupad ng isang gawain

Sa mga karaniwang RTOS, ang isang gawain ay maaaring nasa 3 posibleng estado:

1. Ang gawain ay tinatapos;
2. Ang gawain ay handa nang isakatuparan;
3. Naka-block ang gawain.

Kadalasan, ang karamihan sa mga gawain ay naharang. Isang gawain lamang ang maaaring isagawa sa CPU bawat kasalukuyang sandali oras. Sa mga primitive na RTOS, ang listahan ng mga gawain na handa para sa pagpapatupad ay kadalasang napakaikli;

Ang pangunahing function ng isang RTOS administrator ay ang lumikha ng naturang task scheduler.

Kung ang listahan ng mga gawain na handa para sa pagpapatupad ay naglalaman ng hindi hihigit sa dalawa o tatlo, pagkatapos ay ipinapalagay na ang lahat ng mga gawain ay matatagpuan sa pinakamainam na pagkakasunud-sunod. Kung ang mga ganitong sitwasyon ay nangyari na ang bilang ng mga gawain sa listahan ay lumampas sa pinahihintulutang limitasyon, pagkatapos ay ang mga gawain ay pinagsunod-sunod sa pagkakasunud-sunod ng priyoridad.

Mga algorithm sa pagpaplano

Sa kasalukuyan, dalawang diskarte ang pinaka-masinsinang binuo upang malutas ang problema ng epektibong pagpaplano sa RTOS.

• Mga static na algorithm sa pag-iiskedyul(RMS, Rate Monotonic Scheduling). Gumamit ng priority preemptive scheduling. Ang isang priyoridad ay itinalaga sa bawat gawain bago ito magsimulang isagawa. Ibinibigay ang kagustuhan sa mga gawaing may pinakamaikling panahon ng pagkumpleto.
• Mga dynamic na algorithm sa pag-iiskedyul(EDF, Pinakamaagang Deadline First Scheduling). Ang priyoridad ay itinalaga sa mga gawain nang pabago-bago, na may kagustuhang ibinibigay sa mga gawain na may pinakamaagang simula (pagkumpleto) oras ng pagpapatupad.

Pakikipag-ugnayan sa pagitan ng mga gawain at pagbabahagi ng mapagkukunan

• Pansamantalang hindi pagpapagana ng mga pagkagambala
• Binary semaphores
• Nagpapadala ng mga signal

Karaniwang hindi ginagamit ng mga RTOS ang unang paraan dahil hindi makokontrol ng user application ang processor hangga't gusto nito. Gayunpaman, maraming mga naka-embed na system at RTOS ang nagpapahintulot sa mga application na tumakbo sa kernel mode upang ma-access ang mga tawag sa system at magbigay ng kontrol sa kapaligiran ng pagpapatupad nang walang interbensyon ng OS.

Sa mga single-processor system, ang pinakamahusay na solusyon ay ang patakbuhin ang application sa kernel mode, na pinagana upang harangan ang mga interrupts. Habang ang interrupt ay hindi pinagana, ang application ay may tanging paggamit ng mga mapagkukunan ng proseso at walang ibang gawain o interrupt ang maaaring isagawa. Sa ganitong paraan ang lahat ng mga kritikal na mapagkukunan ay protektado. Matapos makumpleto ng application ang mga kritikal na aktibidad, dapat itong i-unblock ang mga pagkagambala, kung mayroon man. Ang pansamantalang hindi pagpapagana ng isang interrupt ay pinapayagan lamang kapag ang pinakamahabang panahon ng pagpapatupad ng isang kritikal na seksyon ay mas mababa kaysa sa pinapayagang interrupt na oras ng pagtugon. Karaniwan, ang paraan ng proteksyon na ito ay ginagamit lamang kapag ang haba ng kritikal na code ay hindi lalampas sa ilang linya at hindi naglalaman ng mga loop. Ang pamamaraang ito ay perpekto para sa proteksyon ng rehistro.

Kapag ang haba ng kritikal na seksyon ay mas malaki kaysa sa maximum o naglalaman ng mga loop, ang programmer ay dapat gumamit ng mga mekanismo na kapareho o gayahin ang pag-uugali ng mga sistema ng pangkalahatang layunin, tulad ng mga semaphores at signaling.

Paglalaan ng memorya

Ang mga sumusunod na problema sa paglalaan ng memorya ay binibigyan ng higit na pansin sa mga RTOS kaysa sa mga operating system na pangkalahatang layunin.

Una, ang bilis ng paglalaan ng memorya. Ang karaniwang pamamaraan ng paglalaan ng memorya ay nagsasangkot ng pag-scan ng isang listahan ng hindi tiyak na haba upang makahanap ng isang libreng lugar ng memorya binigay na sukat, at ito ay hindi katanggap-tanggap, dahil sa isang RTOS, ang paglalaan ng memorya ay dapat mangyari sa isang nakapirming oras.

Pangalawa, ang memorya ay maaaring maging fragmented kung ang mga libreng seksyon nito ay nahahati na tumatakbong mga proseso. Ito ay maaaring maging sanhi ng paghinto ng programa dahil sa kawalan ng kakayahan nitong gumamit ng bagong lokasyon ng memorya. Ang isang algorithm ng paglalaan ng memorya na unti-unting nagpapataas ng memory fragmentation ay maaaring gumana nang maayos sa mga desktop system kung ang mga ito ay nire-reboot nang hindi bababa sa isang beses sa isang buwan, ngunit hindi katanggap-tanggap para sa mga naka-embed na system na tumatakbo nang maraming taon nang walang pag-reboot.

Ang isang simpleng fixed-length na algorithm ay gumagana nang mahusay sa mga simpleng naka-embed na system.

Ang algorithm na ito ay gumagana rin nang maayos sa mga desktop system, lalo na kapag, habang ang isang core ay nagpoproseso ng isang piraso ng memorya, ang susunod na piraso ng memorya ay pinoproseso ng isa pang core. Mga RTOS na na-optimize sa desktop tulad ng Unison Operating System o DSPnano RTOS ang nagbibigay ng kakayahang ito.

Real-time na operating system (listahan)

Dapat pansinin na ang listahan ay hindi kasama ang mga sistema na binuo sa USSR para sa mga sistema ng militar at espasyo - para sa mga halatang kadahilanan na may kaugnayan sa rehimeng lihim. Gayunpaman, ang kanilang pag-iral at paggamit sa loob ng mga dekada ay isang hindi mapag-aalinlanganang katotohanan na dapat isaalang-alang.

Mga Tala

Panitikan

• Zyl S. QNX real-time na operating system: mula sa teorya hanggang sa pagsasanay. - 2nd ed. - St. Petersburg. : BHV-Petersburg, 2004. - 192 p. - ISBN 5-94157-486-Х
• Zyl S. QNX Momentics. Mga Pangunahing Kaalaman sa Application. - St. Petersburg. : BHV-Petersburg, 2004. - 256 p. - ISBN 5-94157-430-4
• Kurten R. Panimula sa QNX/Neutrino 2. - St. Petersburg. : Petropolis, 2001. - 512 p. - ISBN 5-94656-025-9
• Auslander D.M., Ridgley J.R., Ringenberg J.D. Kontrolin ang mga programa para sa mekanikal na sistema: Object-oriented na disenyo ng mga real-time na system. - M.: Binom. Knowledge Laboratory, 2004. - 416 p. - ISBN 5-94774-097-4

Mga link

• Pangkalahatang-ideya ng mga real-time na operating system

Ang batayan ng anumang hardware at software complex, kabilang ang mga operating sa real time, ay ang operating system (OS). Ang isang operating system ay isang hanay ng mga programa na nagbibigay ng pamamahala ng mga mapagkukunan ng isang hardware-software complex (computer system) at mga proseso na gumagamit ng mga mapagkukunang ito sa mga kalkulasyon. Ang mapagkukunan sa kontekstong ito ay anumang lohikal o pisikal (at sa kabuuan) na bahagi ng isang computing system o hardware at software complex at ang mga kakayahan na ibinibigay nito.

Ang pangunahing mapagkukunan ay ang processor (oras ng processor), RAM at mga peripheral na aparato.

Ang pamamahala ng mapagkukunan ay bumaba sa pagsasagawa ng mga sumusunod na gawain: pagpapasimple ng pag-access sa mga mapagkukunan, pamamahagi ng mga ito sa pagitan ng mga proseso.

Ang solusyon sa unang problema ay nagpapahintulot sa iyo na "itago" ang mga tampok ng hardware ng computing system, at sa gayon ay gawin itong magagamit sa user o programmer. virtual machine na may makabuluhang mas madaling kontrol. Kaya, sinusuportahan ng OS ang mga sumusunod na interface: user (command language para sa pagkontrol sa pagpapatakbo ng system at isang set ng mga serbisyo); software (isang hanay ng mga serbisyo na nagpapalaya sa programmer mula sa mga nakagawiang operasyon ng coding Ang function ng pamamahagi ng mapagkukunan ay isa sa pinakamahalagang gawain na nalutas ng OS, gayunpaman, hindi ito likas sa lahat ng mga OS, ngunit sa mga tinitiyak lamang ang sabay-sabay). pagpapatupad ng ilang mga programa (proseso).

Ang proseso ay isang pagkakasunud-sunod ng mga aksyon na inireseta ng isang programa o ang lohikal na kumpletong bahagi nito, pati na rin ang data na ginamit sa mga kalkulasyon. Ang proseso ay pinakamababang yunit trabaho kung saan inilalaan ang mga mapagkukunan.

Sa kasalukuyan, mayroong isang malawak na iba't ibang mga operating system, na inuri ayon sa mga sumusunod na pamantayan:

o ang bilang ng mga user na sabay-sabay na pinaglilingkuran ng system;

o ang bilang ng mga proseso na maaaring sabay na tumakbo sa ilalim ng kontrol ng OS;

o uri ng access ng user sa system;

o uri ng hardware at software complex.

Alinsunod sa unang pag-sign, ang mga operating system na single- at multi-user ay nakikilala.

Hinahati ng pangalawang tampok ang OS sa single- at multi-tasking.

Alinsunod sa ikatlong tampok, ang mga operating system ay nahahati sa:

o mga sistema na may batch processing. Sa kasong ito, ang isang pakete ay nabuo mula sa mga programa na isasagawa at ipapakita sa system para sa pagproseso. Sa kasong ito, ang mga gumagamit ay hindi direktang nakikipag-ugnayan sa OS;

o time sharing system na nagbibigay ng sabay-sabay na interactive na access sa sistema ng pag-compute maramihang mga gumagamit sa pamamagitan ng mga terminal. Sa kasong ito, ang mga mapagkukunan ng system ay inilalaan sa bawat gumagamit "sa turn", alinsunod sa isa o ibang disiplina ng serbisyo;

o mga real-time na system, na dapat magbigay ng garantisadong oras ng pagtugon sa mga panlabas na kaganapan (tingnan sa ibaba para sa higit pang mga detalye).

Hinahati ng ikaapat na feature ang OS sa single- at multiprocessor, network at distributed. Para sa multi-user at multi-tasking operating system, ang disiplina sa pagpapanatili ay isang mahalagang tagapagpahiwatig. Alinsunod dito, may ginawang pagkakaiba sa pagitan ng preemptive at coordinating mode ng multitasking. Sa isang preemptive na organisasyon, tanging ang OS ang may pananagutan sa paglalaan ng oras ng processor sa mga gawain (halimbawa, para sa bawat gawain, ang isang processor ay inilalaan sa turn, at para sa isang mahigpit na nakapirming tagal ng panahon, ngunit posible rin ang priority servicing). Sa kaso ng isang tumutugmang organisasyon, ang bawat gawain, na nakatanggap ng kontrol, mismo ang tumutukoy kung kailan "ibibigay" ang processor sa isa pang gawain. Sa pangkalahatan, ang koordinasyon ay mas epektibo at maaasahan kaysa sa preemption, ngunit ang pagtukoy sa kadahilanan sa pagpapatupad ng mga programa ay ang katotohanan na programang ito hindi dapat monopolize ang oras ng CPU.

Real Time System (RTS)- ito ay isang sistema, ang tamang paggana nito ay nakasalalay hindi lamang sa lohikal na kawastuhan ng mga kalkulasyon, kundi pati na rin sa oras kung kailan ginawa ang mga kalkulasyong ito.

Para sa mga kaganapang nagaganap sa naturang sistema, ang oras kung kailan nangyari ang mga kaganapang ito at ang kanilang lohikal na kawastuhan ay mahalaga. Gumagana ang isang system sa real time kung ang pagganap nito ay sapat sa bilis ng mga pisikal na proseso sa pagsubaybay o pagkontrol ng mga bagay (ibig sabihin ang mga prosesong direktang nauugnay sa mga function na ginagawa ng isang partikular na real-time na system). Dapat mangolekta ng data ang control system, iproseso ito ayon sa mga tinukoy na algorithm at mag-isyu ng control action sa isang yugto ng panahon na nagsisiguro ng matagumpay na pagkumpleto ng mga nakatalagang gawain.

1.1 Ano ang isang real-time na sistema

SA kani-kanina lang Dumarami, nahaharap tayo sa mga gawain na nangangailangan ng pamamahala ng mga kumplikadong proseso o kagamitan gamit ang isang computer. Bukod dito, ang lahat ng mga kaganapan sa mga prosesong ito ay nangyayari kapag nangyari ang mga ito. Ang isang computer ay maaari lamang magsagawa ng isang may hangganan na bilang ng mga operasyon sa isang takdang panahon, kaya ang tanong ay lumitaw: magkakaroon ba ang computer ng oras upang ang kinakailangang bilis kalkulahin ang sitwasyon at mag-isyu ng mga partikular na pagkilos ng kontrol na magiging sapat na partikular sa tiyak na sandali oras. Sa palagay ko, lumitaw ang mga problema sa ganitong uri dahil sa paggamit ng napaka mataas na bilis V modernong produksyon. Malinaw na ang mga signal sa kalikasan ay nagpapalaganap sa isang may hangganan na bilis, ang bilis ng operasyon ay may hangganan din, samakatuwid ito ay sa panimula imposibleng asahan ang mga instant na aksyon (sanhi ng isang tiyak na kaganapan) mula sa isang computer. Pagkatapos ng lahat, gaano man ka moderno (basahin - malakas sa pagganap, ibig sabihin, mataas na bilis ng pagpoproseso ng mga utos at operasyon) ang isang computer, pisikal na nangangailangan ito ng hindi bababa sa isang bahagi ng isang segundo upang maisagawa ang isang maliit simpleng grupo mga utos, at kung minsan ang oras na ito ay sobra. Kaya, ang oras ng reaksyon ng system sa ilang kaganapan ay mahigpit na mas malaki kaysa sa zero. Ang mga tunay na gawain ay nagbibigay-daan sa ilang pagkaantala sa mga aksyon, at kung ang system ay may oras ng reaksyon na mas mababa kaysa sa katanggap-tanggap na pagkaantala na ito, kung gayon ito ay makatarungang tawagan itong isang real-time na sistema. Dahil sa kalikasan iba't ibang proseso magpatuloy sa iba't ibang bilis, ang isa at ang parehong sistema ay maaaring magkasya sa loob ng ibinigay na balangkas para sa isang proseso at hindi magkasya para sa isa pa. Kaya, makatuwirang pag-usapan ang tungkol sa isang real-time na sistema na may kaugnayan sa isang partikular na gawain. Halimbawa, upang i-plot ang dependence ng average na temperatura ng hangin para sa isang araw sa araw ng linggo, halos anumang computer na may halos anumang software ay gagana bilang isang real-time na sistema. Kung kinokontrol natin ang paglapag ng isang eroplano, kung saan ang mga millisecond ay may mahalagang papel, mas angkop na maingat na pumili ng hardware at software.

Bilang karagdagan sa itinuturing na gawain ng pagtugon sa ilang kaganapan, may iba pang mga klase ng mga real-time na gawain. Ang isa sa mga madalas na nakakaharap ay ang gawain ng patuloy na pagsubaybay o kontrol ng isang dinamikong proseso, i.e. kapag kailangan mong patuloy na makipagpalitan ng signal sa labas ng mundo. Ang isang computer ay isang discrete system, kaya kinakailangan na magsagawa ng ilang mga aksyon na may tiyak na mga takdang panahon, sa pag-aakalang sa mga maikling panahon na ito ang labas ng mundo ay nananatiling hindi nagbabago. Kung ang aming system ay may kakayahang magproseso ng impormasyon at gumawa ng mga signal ng kontrol sa kinakailangang dalas, maaari itong tawaging isang real-time na sistema. Hindi mahirap maunawaan na ang problemang ito ay madaling mabawasan sa nauna, gamit ang simula ng susunod na agwat ng oras bilang isang kaganapan. Ang oras ng reaksyon ay dapat na mas mababa kaysa sa oras ng sampling ng proseso. Kaya, ang gawaing inilarawan kanina ay pinakamahalaga kung kailan pinag-uusapan natin tungkol sa mga real-time system. Dapat tandaan na ang hindi kasiya-siyang pagpapatakbo ng system sa mga tuntunin ng latency sa ilang mga gawain ay maaaring humantong sa nakamamatay na mga kahihinatnan, at sa iba ay walang abnormal o hindi kanais-nais na mga sitwasyon na magaganap. Halimbawa: kung ang sistema ng pagsukat ng temperatura mula sa halimbawang inilarawan sa itaas ay hindi sinasadyang dumating nang huli ng hindi katanggap-tanggap na tagal ng oras, nangangahulugan ito na binago lang namin ang pagpili ng mga punto sa pagbabasa ng temperatura, at makukuha pa rin namin ang tamang resulta, ngunit kung ang awtomatiko Ang diskarte sa isang pampasaherong eroplano ay hindi sinasadyang naantala ng isang segundo sa isang biglaang bugso ng hangin, ang eroplano ay maaaring hindi makarating sa runway at dose-dosenang mga tao ang mamamatay. Kaya, ang mga system ay dapat nahahati sa mahirap at malambot na mga real-time na system.

Ang Real Time OS (RTOS) ay isang OS na ginagarantiyahan ang isang tiyak na kakayahan para sa isang partikular na yugto ng panahon. Halimbawa, maaari itong idisenyo upang ipahiwatig na ang isang bagay ay naging accessible sa isang robot sa isang linya ng pagpupulong. Ang mga naturang shell ay inuri sa "matigas" at "malambot".

Ipinapalagay ng mga hard real-time na operating system na hindi maisasagawa ang pagkalkula kung hindi available ang bagay sa loob ng itinalagang panahon (mabibigo ang naturang operasyon).

Sa isang malambot na real-time na operating system, ang linya ng pagpupulong ay patuloy na gagana sa ilalim ng mga kundisyong ito, ngunit maaaring mas mababa ang produksyon dahil hindi magagamit ang mga bagay sa nakaiskedyul na oras, na nagiging sanhi ng pansamantalang hindi produktibo ang robot.

Bago magbigay ng mga halimbawa ng real-time na operating system, kailangang maunawaan ang mga tampok ng kanilang paggamit. Ang ilang mga naturang operating system ay nilikha para sa mga espesyal na application, ang iba ay para sa mas pangkalahatan. Bilang karagdagan, ang ilang pangkalahatang layunin na shell ay ginagamit din minsan para sa real-time na trabaho. Ang kilalang Windows 2000 o IBM Microsoft/390 ay maaaring magsagawa ng ganitong uri. Iyon ay, kahit na ang OS ay hindi nakakatugon sa ilang mga kinakailangan, maaari itong magkaroon ng mga katangian na nagpapahintulot na ito ay isaalang-alang bilang isang solusyon para sa isang partikular na problema sa aplikasyon sa real time.

Mga halimbawa ng mga operating system at ang kanilang mga katangian

Sa pangkalahatan, ang real time ay may mga sumusunod na katangian:

• Multitasking.
• Mga teknolohikal na batis na maaaring unahin.
• Sapat na bilang ng mga antas ng interrupt.

Ang mga real-time na operating system ay kadalasang ginagamit bilang bahagi ng maliliit na naka-embed na shell na ginagamit sa microdevice na format. Kaya, maaaring ituring ang ilang kernel bilang single-tasking operating system (mga halimbawa: kernel sa IOS, Android, atbp.) sa real time. Gayunpaman, nangangailangan sila ng iba pang bahagi ng device, gaya ng mga driver, upang maisagawa ang kanilang mga nilalayon na gawain. Iyon ang dahilan kung bakit ang isang ganap, bilang panuntunan, ay higit pa sa isang core.

Ang karaniwang halimbawa ng isang RTOS application ay isang HDTV receiver at display. Dapat niyang basahin digital signal, i-decode ito at ipakita ito bilang papasok na data. Ang anumang pagkaantala ay mapapansin bilang pixelated na video at/o distorted na audio.

Kasabay nito, kapag ang isang kahilingan ay ginawa "magbigay ng mga halimbawa ng mga operating system ng ganitong uri," nangangahulugan ito ng pagbanggit sa karamihan mga sikat na pangalan. Ano ang kasama sa grupong ito?

VxWorks mula sa WindRiver

Ang VxWorks ay isang real-time na operating system na binuo bilang proprietary software ng WindRiver. Unang inilabas noong 1987, ang VxWorks ay orihinal na inilaan para sa paggamit sa mga naka-embed na system na nangangailangan ng real-time at deterministikong pagganap. Kaya, ang mga halimbawa ng mga operating system ng ganitong uri ay ginagamit sa mga larangan ng seguridad at kaligtasan, iba't ibang mga industriya (lalo na ang aerospace at pagtatanggol), pagmamanupaktura. mga kagamitang medikal, kagamitang pang-industriya, robotics, enerhiya, pamamahala sa transportasyon, imprastraktura ng network, pagpapabuti ng automotive at consumer electronics.

Sinusuportahan ng VxWorks ang Intel (x86, kabilang ang bagong IntelQuarkSoC at x86-64), MIPS, PowerPC, SH-4 at ARM na mga arkitektura. Kasama ang RTOS na ito malakas na core, intermediate software, bayad na suporta karagdagang mga pakete at mga teknolohiya ng hardware mga tagagawa ng ikatlong partido. Sa pinakahuling release nito - VxWorks 7 - ang system ay muling idinisenyo para sa modularity at upgradeability upang ang OS kernel ay manatiling hiwalay sa middleware, mga application at iba pang mga pakete.

QNX Neutrino

Gayundin ang mga klasikong halimbawa ng mga operating system ng ganitong uri ay ang ilang mga shell na katulad ng Unix. Ito ang QNX Neutrino, na orihinal na binuo noong unang bahagi ng 1980s ng kumpanya sa Canada na Quantum Software Systems. Sa huli, ang pag-unlad ay nakuha ng BlackBerry noong 2010. Ang QNX ay isa sa mga unang komersyal na matagumpay na microkernel operating system, na ginagamit sa iba't ibang mga aparato, kabilang ang kotse at mga mobile phone.

LibrengRTOS

Ang FreeRTOS ay isang sikat na real-time na kernel OS para sa mga naka-embed na device na puno ng 35 microcontrollers. Kumakalat ito sa ilalim Lisensya ng GPL Sa karagdagang paghihigpit at opsyonal na mga pagbubukod. Ipinagbabawal ng paghihigpit ang benchmarking, habang pinapayagan ng exception sariling code mga user kasama ng closed source code, habang pinapanatili ang kernel mismo. Ginagawa nitong mas madaling gamitin ang FreeRTOS sa sarili mong mga application.

Windows CE

Ang Windows Embedded Compact ay isang subfamily ng mga operating system na binuo ng Microsoft Corporation bilang bahagi ng Mga produkto ng Windows Naka-embed. Hindi tulad ng Windows Embedded Standard, na nakabatay sa Windows NT, ang mga sample na operating system na ito ay gumagamit ng eksklusibong hybrid kernel. Nagbibigay ang Microsoft Mga lisensya sa Windows CE para sa mga OEM na maaaring magbago at gumawa ng sarili nilang mga custom na interface, na nagbibigay teknikal na batayan para dito.

Ang mga real-time na operating system (RTOS) ay idinisenyo upang magbigay ng isang interface sa mga mapagkukunan ng kritikal sa oras na mga real-time na system. Ang pangunahing gawain sa naturang mga sistema ay ang pagiging maagap ng pagproseso ng data.

Ang pangunahing kinakailangan para sa isang RTOS ay upang matiyak ang predictability o determinism ng pag-uugali ng system sa ilalim ng pinakamasamang panlabas na mga kondisyon, na naiiba nang husto mula sa mga kinakailangan para sa pagganap at bilis ng mga unibersal na operating system. Ang isang mahusay na RTOS ay may predictable na pag-uugali sa ilalim ng lahat ng mga sitwasyon ng pag-load ng system (sabay-sabay na pagkaantala at pagpapatupad ng thread).

Mayroong ilang pagkakaiba sa pagitan ng mga real-time na system at mga naka-embed na system. Ang isang naka-embed na system ay hindi palaging kinakailangan na magkaroon ng predictable na gawi, kung saan ito ay hindi isang real-time na system. Gayunpaman, kahit na ang isang mabilis na sulyap sa mga posibleng naka-embed na system ay nagpapahiwatig na ang karamihan sa mga naka-embed na system ay nangangailangan ng predictable na pag-uugali, ayon sa kahit man lang, para sa ilang functionality, at sa gayon, ang mga system na ito ay maaaring mauri bilang mga real-time na system.

Nakaugalian na ang pagkilala sa pagitan ng malambot at mahirap na mga real-time na system. Sa mga sistema mahirap talaga kawalan ng kakayahan ng oras na magbigay ng tugon sa anumang mga kaganapan sa tinukoy na oras humahantong sa mga pagkabigo at kawalan ng kakayahan upang makumpleto ang gawain. Sa karamihan ng panitikan sa wikang Ruso, ang mga naturang sistema ay tinatawag na mga sistema na may deterministikong oras. Sa praktikal na aplikasyon ang oras ng reaksyon ay dapat na minimal. Ang mga malalambot na real-time system ay mga system na hindi nasa ilalim ng kahulugan ng "mahirap", dahil Wala pang malinaw na kahulugan para sa kanila sa panitikan. Maaaring walang oras ang mga malalambot na real-time na system upang malutas ang isang problema, ngunit hindi ito humahantong sa pagkabigo ng system sa kabuuan. Sa mga real-time na sistema, kinakailangan na ipakilala ang isang tiyak na deadline (sa Ingles na panitikan - deadline), bago ang pag-expire kung saan ang gawain ay dapat na kinakailangan (para sa malambot na real-time system - mas mabuti) na makumpleto. Ang deadline na ito ay ginagamit ng task scheduler para magtalaga ng priyoridad sa isang gawain kapag ito ay inilunsad at kapag pumipili ng isang gawain para sa pagpapatupad.

Si Martin Timmerman ay bumalangkas ng mga sumusunod na kinakailangang kinakailangan para sa isang RTOS:

• Ang OS ay dapat na multitasking at preemptable,
• Ang OS ay dapat magkaroon ng isang konsepto ng priyoridad para sa mga thread,
• Dapat suportahan ng OS ang mga predictable na mekanismo ng pag-synchronize,
• Ang OS ay dapat magbigay ng isang mekanismo para sa pagmamana ng mga priyoridad,
• Dapat malaman at mahuhulaan ang pag-uugali ng OS (mga pagkaantala sa pagproseso ng interrupt, pagkaantala sa paglipat ng gawain, pagkaantala ng driver, atbp.); nangangahulugan ito na sa lahat ng sitwasyon ng workload ng system, dapat matukoy ang maximum na oras ng pagtugon.

Sa nakalipas na 25-30 taon, ang istraktura ng mga operating system ay nagbago mula sa monolitik hanggang sa multi-layer na istraktura ng OS at pagkatapos ay sa arkitektura ng client-server. Sa isang monolitikong istraktura, ang OS ay binubuo ng isang hanay ng mga module, at ang mga pagbabago sa isang module ay nakakaapekto sa iba pang mga module. Ang mas maraming mga module, mas maraming kaguluhan ang nangyayari sa panahon ng pagpapatakbo ng naturang sistema. Bukod pa rito, hindi posible na ipamahagi ang OS sa isang multiprocessor system. Sa isang multilayer na istraktura, ang mga pagbabago sa isang layer ay nakakaapekto sa mga katabing layer; bilang karagdagan, ang pagbabaligtad sa pamamagitan ng layer ay hindi posible. Para sa mga real-time na system, dapat magbigay ng direktang access sa bawat layer ng OS, at minsan direkta sa hardware.

Ang pangunahing ideya ng teknolohiya ng client-server sa isang OS ay upang bawasan ang batayan ng OS sa pinakamababa (mga primitive ng scheduler at synchronization). Ang lahat ng iba pang functionality ay inilipat sa ibang antas at ipinatupad sa pamamagitan ng mga thread o mga gawain. Ang isang set ng naturang mga gawain sa server ay responsable para sa mga tawag sa system. Ang mga application ay mga kliyente na humihiling ng mga serbisyo sa pamamagitan ng mga system call.

Ang teknolohiya ng Client-server ay nagbibigay-daan sa paglikha ng mga scalable operating system at pinapasimple ang pamamahagi sa isang multiprocessor system. Kapag nagpapatakbo ng system, ang pagpapalit ng isang module ay hindi nagdudulot ng "snowball" na epekto; Bilang karagdagan, ang pagkabigo ng module ay hindi palaging nangangailangan ng pagkabigo ng system sa kabuuan. Mayroon na ngayong kakayahang dynamic na mag-load at mag-unload ng mga module. Ang pangunahing problema sa modelong ito ay memory protection, dahil ang mga proseso ng server ay dapat protektado. Sa tuwing may gagawing kahilingan sa serbisyo, dapat lumipat ang system mula sa konteksto ng aplikasyon patungo sa konteksto ng server. Sa suporta sa proteksyon ng memorya, tumataas ang oras ng paglipat mula sa isang proseso patungo sa isa pa.

Bilang isang patakaran, karamihan sa mga modernong RTOS ay binuo batay sa isang microkernel (kernel o nucleus), na nagbibigay ng pag-iiskedyul at pagpapadala ng mga gawain, pati na rin ang kanilang pakikipag-ugnayan. Kahit na pinapaliit ng kernel ang mga abstraction ng OS, kailangan pa rin ng microkernel na magkaroon ng pag-unawa sa abstraction ng proseso. Ang lahat ng iba pang mga konseptong abstraction ng mga operating system ay inilipat sa labas ng kernel, tinawag kapag hiniling, at isinasagawa bilang mga aplikasyon.

Mga Natatanging Tampok RTOS mula sa isang pangkalahatang layunin na OS

Pangkalahatang layunin ng mga operating system, lalo na ang mga multi-user tulad ng UNIX, ay nilalayon pinakamainam na pamamahagi mga mapagkukunan ng computer sa pagitan ng mga gumagamit at mga gawain. Sa real-time na mga operating system, ang ganoong gawain ay nawawala sa background - lahat ay umuurong bago pangunahing gawain- magkaroon ng oras upang mag-react sa mga kaganapan na nagaganap sa pasilidad Ang isa pang pagkakaiba ay ang paggamit ng isang real-time na operating system ay palaging nauugnay sa kagamitan, sa bagay, sa mga kaganapan na nagaganap sa pasilidad. Ang isang real-time na operating system ay nakatuon sa pagproseso ng mga panlabas na kaganapan. Ang isang real-time na operating system ay maaaring magkatulad sa user interface sa isang pangkalahatang layunin na OS, ngunit ito ay ganap na naiiba sa pagkakaayos Bilang karagdagan, ang paggamit ng mga real-time na operating system ay palaging partikular. Kung ang isang pangkalahatang layunin na OS ay karaniwang nakikita ng mga gumagamit (hindi mga developer) bilang isang handa na hanay ng mga application, kung gayon ang isang real-time na operating system ay nagsisilbi lamang bilang isang tool para sa paglikha ng isang partikular na real-time na hardware at software complex. At samakatuwid, ang pinakamalawak na klase ng mga user ng real-time na operating system ay mga developer ng real-time system, mga taong nagdidisenyo ng control at data acquisition system. Kapag nagdidisenyo at nagde-develop ng isang partikular na real-time system, palaging alam ng programmer kung ano ang mga kaganapan na maaaring mangyari sa pasilidad, at alam ang kritikal na time frame para sa pagseserbisyo sa bawat isa sa mga kaganapang ito sa pasilidad sa loob ng oras na kritikal para sa kaganapang ito. Ang halaga ng kritikal na oras para sa bawat kaganapan ay tinutukoy ng bagay at ng kaganapan mismo, at maaaring magkakaiba, ngunit ang oras ng reaksyon ng system ay dapat mahulaan (kinakalkula) kapag lumilikha ng system. Ang pagkabigong tumugon sa hinulaang oras ay itinuturing na isang error para sa mga real-time na system Dapat na makatugon ang system sa mga magkakasabay na kaganapan. Kahit na dalawa o higit pang mga panlabas na kaganapan ang nangyari nang sabay-sabay, ang system ay dapat magkaroon ng oras upang tumugon sa bawat isa sa kanila sa loob ng mga pagitan ng oras na kritikal para sa mga kaganapang ito.

Matigas at malambot na real-time system

Mayroong dalawang uri ng real-time system - hard real-time system at soft real-time system.

Hindi pinapayagan ng mga hard real-time na system ang anumang pagkaantala sa pagtugon ng system sa anumang sitwasyon dahil:

• ang mga resulta ay maaaring walang silbi kung huli
• sakuna ay maaaring mangyari kung ang reaksyon ay naantala

• ang halaga ng pagiging huli ay maaaring walang katapusan.

Ang mga halimbawa ng mga hard real-time na system ay on-board control system, emergency protection system, emergency event recorder.

Ang mga malalambot na real-time na sistema ay nailalarawan sa katotohanan na ang pagkaantala ng pagtugon ay hindi kritikal, bagaman maaari itong humantong sa pagtaas sa halaga ng mga resulta at pagbaba sa pagganap ng system sa kabuuan. Kung ang system ay walang oras upang iproseso ang susunod na natanggap na packet, hahantong ito sa isang timeout sa gilid ng pagpapadala at muling pagpapadala (depende sa protocol, siyempre). Ang data ay hindi nawawala, ngunit ang pagganap ng network ay nabawasan. mahirap na sistema ang real time ay hindi kailanman mahuhuli sa pagre-react sa isang kaganapan, ang isang malambot na real time system ay hindi dapat huli sa pagre-react sa isang kaganapan

Kernel ng operating system

Ang kernel ay ang sentral na bahagi ng operating system (OS), na nagbibigay ng mga application na may coordinated na pag-access sa mga mapagkukunan ng computer, memorya, panlabas na hardware, panlabas na input at output na mga aparato, na nagsasalin ng mga utos ng wika ng aplikasyon sa binary code na wika na naiintindihan ng computer elemento ng OS, ang kernel ang pinaka kinakatawan mababang antas abstraction para sa mga application upang ma-access ang mga mapagkukunan ng system na kinakailangan para sa kanilang operasyon. Karaniwan, ang kernel ay nagbibigay ng ganoong access sa mga proseso ng pagpapatupad ng kaukulang mga aplikasyon sa pamamagitan ng paggamit ng mga mekanismo. interprocess na komunikasyon at mga tawag sa aplikasyon sa mga tawag sa system OS.

Monolithic core

Ang monolithic kernel ay nagbibigay ng isang rich set ng hardware abstractions. Ang lahat ng bahagi ng isang monolithic kernel ay gumagana sa parehong address space. Ito ay isang disenyo ng operating system kung saan ang lahat ng bahagi ng kernel nito ay mga bahagi isang programa, gamitin pangkalahatang istruktura data at nakikipag-ugnayan sa isa't isa sa pamamagitan ng direktang pagtawag sa mga pamamaraan. Monolithic core - ang pinakamatandang paraan organisasyon ng mga operating system. Ang isang halimbawa ng mga system na may monolitikong kernel ay ang karamihan sa mga sistema ng UNIX.

Mga kalamangan: Bilis ng operasyon, pinasimple na pag-unlad ng mga module.

Mga kapintasan: Dahil ang buong kernel ay gumagana sa parehong address space, ang pagkabigo sa isa sa mga bahagi ay maaaring makagambala sa buong system.

Ang ilang lumang monolithic kernels, lalo na ang UNIX/Linux-class system, ay nangangailangan ng recompilation sa tuwing nagbabago ang komposisyon ng hardware. Karamihan modernong mga butil pinapayagan kang mag-load ng mga module sa panahon ng operasyon na gumaganap ng bahagi ng mga function ng kernel. Sa kasong ito, ang mga bahagi ng operating system ay hindi mga independiyenteng module, at ang mga bahagi ng isa malaking programa tinatawag na monolithic kernel, na isang hanay ng mga pamamaraan, bawat isa ay maaaring tumawag sa bawat isa. Ang lahat ng mga pamamaraan ay tumatakbo sa privileged mode.

Microkernel

Ang microkernel ay nagbibigay lamang ng mga pangunahing function ng control ng proseso at isang minimal na hanay ng mga abstraction para sa pagtatrabaho sa hardware. Karamihan sa mga gawain ay ginagawa sa pamamagitan ng mga espesyal na proseso ng user na tinatawag na mga serbisyo. Ang mapagpasyang pamantayan para sa "microkernelism" ay ang paglalagay ng lahat o halos lahat ng mga driver at module sa mga proseso ng serbisyo.

Mga kalamangan: Paglaban sa mga pagkabigo ng hardware at mga error sa mga bahagi ng system. Ang pangunahing bentahe ng arkitektura ng microkernel ay mataas na antas modularity ng kernel ng operating system. Ginagawa nitong mas madaling magdagdag ng mga bagong bahagi dito. Sa isang microkernel operating system, maaari kang mag-load at mag-unload ng mga bagong driver, file system, atbp. nang hindi naaabala ang operasyon nito Ang proseso ng pag-debug ng mga bahagi ng kernel ay makabuluhang pinasimple, dahil bagong bersyon maaaring i-load ang mga driver nang hindi na-restart ang buong operating system. Ang mga bahagi ng kernel ng operating system ay walang panimula na naiiba sa mga program ng user, kaya maaari mong gamitin ang mga ordinaryong tool upang i-debug ang mga ito. Ang arkitektura ng microkernel ay nagpapabuti sa pagiging maaasahan ng system dahil ang isang pagkabigo sa antas ng programa na walang pribilehiyo ay hindi gaanong mapanganib kaysa sa isang pagkabigo sa antas ng kernel mode.

Mga kapintasan: Ang pagpasa ng data sa pagitan ng mga proseso ay nangangailangan ng overhead.

Runtime na kapaligiran

Ang mga kinakailangan para sa kapaligiran ng pagpapatupad ng mga real-time na system ay ang mga sumusunod:

• maliit na memorya ng system - para sa posibilidad ng pag-embed nito;
• ang system ay dapat na ganap na naninirahan sa memorya upang maiwasan ang paging ng memorya o pagpapalit;
• ang system ay dapat na multitasking - upang matiyak ang maximum epektibong paggamit lahat ng mga mapagkukunan ng system;
• core na may priyoridad para sa servicing interrupts. Nangangahulugan ang interrupt priority na ang isang proseso na handang tumakbo at may partikular na priyoridad ay kinakailangang may priyoridad sa pila kaysa sa isang proseso na may mas mababang priyoridad, mabilis na pinapalitan ang huli at nagpapatuloy sa pagpapatupad. Tinatapos ng core ang anuman gawaing paglilingkod, sa sandaling dumating ang isang gawain kasama pangunahing priyoridad. Tinitiyak nito ang predictability ng system;
• priority manager - nagbibigay-daan sa developer ng application na magtalaga ng bawat boot module ng priyoridad na hindi napapailalim sa system. Ang priyoridad na pagtatalaga ay ginagamit upang matukoy ang pagkakasunud-sunod kung saan ang mga program na handa nang isagawa ay tatakbo. Ang isang alternatibo sa ganitong uri ng pag-iiskedyul ay ang pag-iskedyul ng carousel, kung saan ang bawat programa na handang magpatuloy ay binibigyan ng pantay na pagkakataong tumakbo. Sa pamamaraang ito, walang kontrol sa kung aling programa ang isasagawa at kung kailan. Ito ay hindi katanggap-tanggap sa isang real-time na kapaligiran. Ang dispatch na nakabatay sa priyoridad at isang interrupt-priority na kernel ay nagbibigay sa developer ng application ng kumpletong kontrol sa system. Kung may nangyaring mas mataas na priyoridad na kaganapan, hihinto ang system sa pagproseso ng mas mababang priyoridad na gawain at tumugon sa bagong natanggap na kahilingan.

Ang kumbinasyon ng mga katangiang inilarawan sa itaas ay lumilikha ng isang malakas at mahusay na real-time na kapaligiran sa pagpapatupad.

Bilang karagdagan sa mga katangian ng runtime environment, kinakailangan ding isaalang-alang ang serbisyong ibinigay ng kernel ng real-time na OS. Ang core ng anumang real-time na runtime na kapaligiran ay ang kernel o dispatcher. Kinokontrol ng kernel ang hardware ng target na computer: gitnang processor, memory at input/output device; kinokontrol ang pagpapatakbo ng lahat ng iba pang mga sistema at software ng isang inilapat na kalikasan. Sa isang real-time na system, ang dispatcher ay nakaupo sa pagitan ng hardware ng target na computer at ng application software. Nagbibigay ito espesyal na serbisyo, kinakailangan para sa pagpapatakbo ng mga real-time na application. Ang serbisyong ibinigay ng kernel ay nagbibigay mga programa sa aplikasyon access sa mga mapagkukunan ng system tulad ng memorya o input/output device.

Ang kernel ay maaaring magbigay ng iba't ibang uri ng mga serbisyo:

• Pagpapalitan ng intertask. Kadalasang kinakailangan na maglipat ng data sa pagitan ng mga programa sa loob ng parehong sistema Bilang karagdagan, maraming mga aplikasyon ang kailangang makipag-ugnayan sa ibang mga sistema sa isang network. Intercom maaaring gawin sa pamamagitan ng isang sistema ng pagmemensahe. Mga panlabas na komunikasyon maaaring ayusin sa pamamagitan ng isang datagram ( pinakamahusay na paraan paghahatid), o sa pamamagitan ng mga linya ng komunikasyon (garantisadong paghahatid). Ang pagpili ng isang paraan o iba ay depende sa protocol ng komunikasyon.
• Paghihiwalay ng data. Sa mga real-time na application, ang pagkolekta ng data ay tumatagal ng pinakamahabang oras. Ang data ay madalas na kinakailangan para sa pagpapatakbo ng iba pang mga programa o kinakailangan ng system upang maisagawa ang ilan sa mga function nito. Maraming mga sistema ang nagbibigay ng access sa pangkalahatang mga seksyon alaala. Laganap ang data queuing. Mayroong maraming mga uri ng pila na ginagamit, bawat isa ay may sariling mga pakinabang.
• Pagproseso ng mga kahilingan mula sa mga panlabas na device. Ang bawat application program ay konektado sa real time sa isang panlabas na device tiyak na uri. Ang kernel ay dapat magbigay ng mga serbisyo ng I/O na nagbibigay-daan sa mga application program na magbasa at sumulat sa mga device na ito. Para sa mga real-time na application, karaniwan na magkaroon ng a ang application na ito panlabas na aparato. Ang kernel ay dapat magbigay ng isang serbisyo na nagpapadali sa pagtatrabaho sa mga driver ng device. Halimbawa, gawing posible ang pag-record sa mga wika mataas na antas- tulad ng C o Pascal.
• Paghawak ng mga espesyal na sitwasyon. Ang pagbubukod ay isang kaganapan na nangyayari sa panahon ng pagpapatupad ng programa. Maaari itong maging kasabay kung ang paglitaw nito ay predictable, tulad ng paghahati sa pamamagitan ng zero. At maaari rin itong maging asynchronous kung ito ay nangyayari nang hindi mahuhulaan, tulad ng pagbaba ng boltahe. Ang pagbibigay ng kakayahang pangasiwaan ang mga ganitong uri ng mga kaganapan ay nagbibigay-daan sa mga real-time na application na tumugon nang mabilis at predictably sa panloob at panlabas na mga kaganapan. Mayroong dalawang paraan para sa paghawak ng mga eksepsiyon - gamit ang mga halaga ng estado upang makita ang mga kundisyon ng error at paggamit ng isang exception handler upang ma-trap ang mga kundisyon ng error at itama ang mga ito.

Pangkalahatang-ideya ng mga arkitektura ng RTOS

Sa paglipas ng kasaysayan nito, ang arkitektura ng operating system ay sumailalim sa makabuluhang pag-unlad. Isa sa mga unang prinsipyo ng konstruksiyon, monolitik Ang OS (Figure 1) ay binubuo ng pagpapakita ng OS bilang isang set ng mga module na nakikipag-ugnayan sa isa't isa sa iba't ibang paraan sa loob ng core ng system at nagbibigay ng mga application program na may mga input interface para sa pag-access ng hardware.

antas ng OS (Figure 2). Sistema ng MS-DOS. Sa mga system ng klase na ito, maaaring ma-access ng mga application application ang hardware hindi lamang sa pamamagitan ng system kernel o sa mga serbisyo ng residente nito, ngunit direkta din. Ang mga RTOS ay binuo sa prinsipyong ito sa loob ng maraming taon. Kung ikukumpara sa mga monolitikong operating system, ang arkitektura na ito ay nagbibigay ng mas mataas na antas ng predictability ng mga reaksyon ng system, at nagbibigay-daan din sa mga application application na mabilis na ma-access ang hardware. Disadvantage

Ang nakakapagpasama sa mga ganitong sistema ay ang kanilang kakulangan ng multitasking. Sa loob ng arkitektura na ito, ang problema sa pagproseso ng mga asynchronous na kaganapan ay nabawasan sa pag-buffer ng mga mensahe, at pagkatapos ay sunud-sunod na botohan ang mga buffer at pinoproseso ang mga ito. Kasabay nito, ang pagsunod sa mga kritikal na deadline ng serbisyo ay natiyak ng mataas na pagganap ng computing complex kumpara sa bilis ng mga panlabas na proseso.

Figure 2. Layered OS architecture

Ang isa sa mga pinaka-epektibong arkitektura para sa pagbuo ng mga real-time na operating system ay ang arkitektura ng client-server. Pangkalahatang pamamaraan Ang isang OS na nagpapatakbo gamit ang teknolohiyang ito ay ipinapakita sa Figure 3. Ang pangunahing prinsipyo ng arkitektura na ito ay ang paglipat ng mga serbisyo ng OS sa anyo ng mga server sa antas ng user, at ang microkernel ay kumikilos bilang isang tagapamahala ng mensahe sa pagitan ng mga programa ng gumagamit ng kliyente at mga server - system serbisyo. Ang arkitektura na ito ay nagbibigay ng maraming pakinabang sa mga tuntunin ng mga kinakailangan para sa RTOS at mga naka-embed na system. Kabilang sa mga pakinabang na ito ay:

1. Ang pagiging maaasahan ng OS ay tumataas, dahil Ang bawat serbisyo ay, sa katunayan, isang independiyenteng application at mas madaling i-debug at subaybayan ang mga error.

2. Ang ganitong sistema ay mas nasusukat, dahil ang mga hindi kinakailangang serbisyo ay maaaring hindi isama sa system nang hindi nakompromiso ang pagganap nito.

3. Tumataas ang fault tolerance ng system, dahil Ang isang nakapirming serbisyo ay maaaring i-restart nang wala

i-reboot ang system.

Figure 3. Pagbuo ng OS gamit ang arkitektura ng client-server

Sa kasamaang palad, ngayon walang maraming mga operating system na ipinatupad sa prinsipyo ng client-server. Kabilang sa mga kilalang RTOS na nagpapatupad ng arkitektura ng microkernel ay ang OS9 at QNX.

Listahan ng ginamit na panitikan:

1) http://ru.wikipedia.org/wiki/Real_time_operating system

2) http://www.asutp.ru/?p=600591

3) http://www.mka.ru/?p=40774

4) http://www.4stud.info/rtos/lecture1.html

5)http://www.ozon.ru/context/detail/id/3092042/