De basis van elk hardware- en softwarecomplex, ook als het in realtime werkt, is het besturingssysteem (OS). Een besturingssysteem is een complex van programma's dat zorgt voor het beheer van de bronnen van een hardware-softwarecomplex (computersysteem) en processen die deze bronnen gebruiken bij berekeningen. Een hulpmiddel is in deze context elk logisch of fysiek (en in totaal) onderdeel van een computersysteem of hardware-softwarecomplex en de mogelijkheden die het biedt.

De belangrijkste bronnen zijn processor (CPU-tijd), RAM en randapparatuur.

Resourcemanagement komt neer op het uitvoeren van de volgende taken: de toegang tot resources vereenvoudigen, deze verdelen tussen processen.

De oplossing van het eerste probleem maakt het mogelijk om de hardwarekenmerken van het computersysteem te "verbergen", en daardoor de gebruiker of programmeur te voorzien van een virtuele machine met aanzienlijk eenvoudigere controle. Het besturingssysteem ondersteunt dus de volgende interfaces: gebruikersinterface (opdrachttaal voor het beheer van de werking van het systeem en een reeks services); software (een reeks services die de programmeur bevrijdt van routinematige codeerbewerkingen) De functie voor het toewijzen van bronnen is een van de belangrijkste taken die door het besturingssysteem worden opgelost, maar het is niet inherent aan alle besturingssystemen, maar alleen in die welke zorgen voor de gelijktijdige uitvoering van meerdere programma's (processen).

Een proces is een opeenvolging van acties die worden voorgeschreven door een programma of het logisch volledige onderdeel ervan, evenals gegevens die in berekeningen worden gebruikt. Een proces is de kleinste werkeenheid waarvoor middelen worden toegewezen.

Momenteel is er een grote verscheidenheid aan besturingssystemen, die zijn geclassificeerd volgens de volgende criteria:

o het aantal gebruikers dat tegelijkertijd door het systeem wordt bediend;

o het aantal processen dat gelijktijdig kan worden uitgevoerd onder besturing van het besturingssysteem;

o type gebruikerstoegang tot het systeem;

o type hard- en softwarecomplex.

In overeenstemming met het eerste kenmerk worden besturingssystemen voor één en meerdere gebruikers onderscheiden.

De tweede functie verdeelt het besturingssysteem in single- en multitasking.

In overeenstemming met de derde functie zijn besturingssystemen onderverdeeld in:

o systemen met batchverwerking. In dit geval wordt uit de uit te voeren programma's een pakket gevormd dat ter verwerking aan het systeem wordt aangeboden. In dit geval hebben gebruikers geen directe interactie met het besturingssysteem;

o systemen voor het delen van tijd die gelijktijdige interactieve toegang bieden tot het computersysteem van meerdere gebruikers via terminals. In dit geval worden systeembronnen "op zijn beurt" toegewezen aan elke gebruiker in overeenstemming met een of andere servicediscipline;

o real-time systemen, die een gegarandeerde responstijd moeten bieden op externe gebeurtenissen (zie hieronder voor meer details).

De vierde functie verdeelt het besturingssysteem in enkele en multiprocessor, netwerk en gedistribueerd. Voor multi-user en multitasking besturingssystemen is servicediscipline een belangrijke maatstaf. In overeenstemming hiermee worden preventieve en matching-modi van multitasking onderscheiden. Bij een preventieve organisatie houdt alleen het besturingssysteem zich bezig met de toewijzing van processortijd aan taken (bijvoorbeeld voor elke taak wordt de processor op zijn beurt toegewezen en voor een strikt vastgestelde periode, maar prioriteitsservice is ook mogelijk). In het geval van een coördinerende organisatie bepaalt elke taak, die de controle heeft gekregen, zelf wanneer de verwerker aan een andere taak moet worden "gegeven". In het algemeen is reconciliatie efficiënter en betrouwbaarder dan preemption, maar de bepalende factor bij de implementatie van programma's is het feit dat een bepaald programma niet uitsluitend processortijd mag gebruiken.

Realtime systeem (SRV) is een systeem waarvan de juiste werking niet alleen afhangt van de logische juistheid van berekeningen, maar ook van de tijd waarin deze berekeningen worden gemaakt.

Voor gebeurtenissen die in een dergelijk systeem plaatsvinden, is het tijdstip waarop deze gebeurtenissen plaatsvinden en hun logische juistheid van belang. Het systeem werkt in realtime als de snelheid voldoende is voor de snelheid van de fysieke processen op de objecten van monitoring of controle (we bedoelen de processen die rechtstreeks verband houden met de functies die door een specifiek realtime systeem worden uitgevoerd). Het controlesysteem moet gegevens verzamelen, verwerken volgens de gespecificeerde algoritmen en een controleactie uitvaardigen voor een dergelijke periode die de succesvolle voltooiing van de toegewezen taken garandeert.

1.1 Wat is een realtime systeem?

De laatste tijd hebben we steeds vaker te maken met taken die de besturing van complexe processen of apparatuur met behulp van een computer vereisen. Bovendien vinden alle gebeurtenissen in deze processen plaats wanneer ze zich voordoen. Een computer daarentegen kan slechts een eindig aantal bewerkingen op een eindig tijdstip uitvoeren, dus de vraag rijst: heeft de computer de tijd om de situatie met de vereiste snelheid te berekenen en specifieke controleacties uit te voeren die bij een bepaalde bepaald tijdstip. Naar mijn mening zijn dit soort problemen ontstaan ​​door het gebruik van zeer hoge snelheden in de moderne productie. Het is duidelijk dat signalen in de natuur zich met een eindige snelheid voortplanten, de werksnelheid is ook eindig, daarom is het principieel onmogelijk om onmiddellijke acties (veroorzaakt door een bepaalde gebeurtenis) van een computer te verwachten. Immers, hoe modern (lees - krachtig in termen van prestaties, dwz hoge verwerkingssnelheid van opdrachten en bewerkingen) een computer ook is, hij heeft fysiek minstens een fractie van een seconde nodig om een ​​kleine eenvoudige groep opdrachten uit te voeren, en soms deze keer is te veel. De reactietijd van het systeem op een bepaalde gebeurtenis is dus strikt groter dan nul. Echte taken laten enige vertraging toe in acties, en als het systeem een ​​responstijd heeft die korter is dan deze toelaatbare vertraging, dan wordt het met recht een realtime systeem genoemd. Omdat in de natuur verschillende processen met verschillende snelheden verlopen, kan het ene en hetzelfde systeem voor het ene proces in een bepaald kader passen en niet voor het andere. Het is dus logisch om te praten over een realtime systeem in relatie tot een specifieke taak. Om bijvoorbeeld de afhankelijkheid van de gemiddelde luchttemperatuur per dag op de dag van de week in kaart te brengen, kan bijna elke computer met bijna elke software als realtime systeem worden gebruikt. Als we de landing van een vliegtuig beheren, waarbij milliseconden een grote rol spelen, is het verstandiger om hardware en software zorgvuldig te kiezen.

Naast de weloverwogen taak om op een bepaalde gebeurtenis te reageren, zijn er nog andere klassen van realtime taken. Een van de meest voorkomende taken is het constant bewaken of beheersen van een dynamisch proces, d.w.z. wanneer je continu signalen moet uitwisselen met de buitenwereld. Een computer is een discreet systeem, daarom is het noodzakelijk om enkele acties uit te voeren met enkele eindige tijdsintervallen, ervan uitgaande dat tijdens deze kleine intervallen de buitenwereld onveranderd blijft. Als ons systeem in staat is om informatie te verwerken en stuursignalen met de gewenste frequentie af te geven, dan is er sprake van een realtime systeem. Het is gemakkelijk te begrijpen dat deze taak gemakkelijk kan worden teruggebracht tot de vorige, door het begin van het volgende tijdsinterval als een gebeurtenis te gebruiken. De responstijd moet korter zijn dan de procesbemonsteringstijd. De eerder beschreven taak is dus de belangrijkste als het gaat om realtime-systemen. Opgemerkt moet worden dat het onbevredigend achterblijven van het systeem in sommige taken tot fatale gevolgen kan leiden, en in sommige zullen er geen buitengewone en ongewenste situaties zijn. Bijvoorbeeld: als het temperatuurmeetsysteem uit het hierboven beschreven voorbeeld per ongeluk op een onaanvaardbaar tijdstip arriveert, dan betekent dit dat we eenvoudig de bemonstering van temperatuurophaalpunten hebben gewijzigd en we nog steeds het juiste resultaat krijgen, als de automatische naderingsmachine in een passagiersvliegtuig wordt per ongeluk een seconde vertraagd wanneer een plotselinge windvlaag het vliegtuig mogelijk niet de landingsbaan raakt en tientallen mensen zullen sterven. Systemen moeten dus worden onderverdeeld in harde en zachte realtime-systemen.

Realtime besturingssysteem

Een besturingssysteem dat zelfs de vereiste uitvoeringstijd van de realtime-taak kan leveren in het ergste geval wordt genoemd hard real-time besturingssysteem.

Een besturingssysteem dat de vereiste uitvoeringstijd voor een realtime taak kan bieden gemiddeld wordt genoemd zacht realtime besturingssysteem.

Harde real-time systemen staan ​​geen vertragingen in de reactie van het systeem toe, omdat dit kan leiden tot:

• verlies van relevantie van resultaten
• grote financiële verliezen
• ongevallen en rampen

Als kritieke situaties niet of niet snel genoeg worden afgehandeld, onderbreekt het harde realtimesysteem de operatie en blokkeert het zodat de betrouwbaarheid en beschikbaarheid van de rest van het systeem niet in gevaar komt. Voorbeelden van harde real-time systemen zijn controlesystemen aan boord (in een vliegtuig, ruimtevaartuig, schip, enz.), noodbeveiligingssystemen, noodgebeurtenisrecorders.

Zachte real-time systemen worden gekenmerkt door de mogelijkheid om de respons te vertragen, wat kan leiden tot een stijging van de kosten van resultaten en een afname van de prestaties van het systeem als geheel. Een voorbeeld is de werking van een computernetwerk. Als het systeem geen tijd had om het volgende ontvangen pakket te verwerken, zal dit leiden tot een stop aan de verzendende kant en opnieuw verzenden (afhankelijk van het protocol). Er gaan geen gegevens verloren, maar de netwerkprestaties worden verminderd.

Het belangrijkste verschil tussen harde en zachte real-time systemen kan als volgt worden gekarakteriseerd: een hard real-time systeem zal nooit te laat reageren op een gebeurtenis, een zacht real-time systeem mag niet te laat reageren op een gebeurtenis.

Laten we een real-time besturingssysteem aanduiden als een systeem dat gebruikt kan worden om harde real-time systemen te bouwen. Deze definitie geeft uitdrukking aan de houding ten opzichte van de RTOS ten aanzien van het object dat de benodigde gereedschappen bevat, maar betekent ook dat deze gereedschappen nog correct moeten worden gebruikt.

De meeste software is soft real-time georiënteerd. Dergelijke systemen worden gekenmerkt door:

• gegarandeerde responstijd op externe gebeurtenissen (storingen door apparatuur);
• een rigide subsysteem voor het plannen van processen (taken met een hoge prioriteit mogen niet worden vervangen door taken met een lage prioriteit, op enkele uitzonderingen na);
• verhoogde vereisten voor de responstijd op externe gebeurtenissen of reactiviteit (de vertraging bij het aanroepen van de interrupt-handler is niet meer dan tientallen microseconden, de vertraging bij het schakelen van taken is niet meer dan honderden microseconden)

Een klassiek voorbeeld van een taak waarvoor een RTOS nodig is, is het besturen van een robot die een onderdeel van een lopende band haalt. Het onderdeel beweegt en de robot heeft maar een korte tijd om het op te rapen. Is hij te laat, dan bevindt het onderdeel zich niet meer in het gewenste gedeelte van de transportband en wordt het werk dus niet voltooid, ondanks dat de robot op de juiste plaats staat. Als hij zich eerder voorbereidt, heeft het onderdeel nog geen tijd om naar boven te rijden en blokkeert hij zijn pad.

Onderscheidende kenmerken van RTOS

Vergelijkingstabel van RTOS en conventionele besturingssystemen:

RTOS-architecturen

Bij de ontwikkeling is RTOS gebouwd op basis van de volgende architecturen.

• ... Een besturingssysteem wordt gedefinieerd als een set modules die met elkaar interageren binnen de systeemkernel en applicatiesoftware voorzien van invoerinterfaces voor toegang tot hardware. Het belangrijkste nadeel van dit principe van het bouwen van een besturingssysteem is de slechte voorspelbaarheid van het gedrag, veroorzaakt door de complexe interactie van modules met elkaar.
• ... Applicatiesoftware heeft niet alleen toegang tot hardware via de systeemkern en zijn services, maar ook rechtstreeks. Vergeleken met een monolithische architectuur biedt een dergelijke architectuur een veel grotere mate van voorspelbaarheid van systeemreacties, en stelt ze applicatietoepassingen ook in staat snel toegang te krijgen tot hardware. Het grootste nadeel van dergelijke systemen is het gebrek aan multitasking.
• Client-server-architectuur... Het belangrijkste principe is om OS-services in de vorm van servers naar het gebruikersniveau te brengen en de microkernel vervult de functies van een berichtverzender tussen clientgebruikersprogramma's en servers - systeemservices. De voordelen van deze architectuur:

1. Verhoogde betrouwbaarheid, aangezien elke service in feite een onafhankelijke applicatie is en het gemakkelijker is om fouten te debuggen en op te sporen;
2. Verbeterde schaalbaarheid, omdat onnodige services van het systeem kunnen worden uitgesloten zonder de prestaties te beïnvloeden;
3. Verhoogde fouttolerantie, omdat een bevroren service opnieuw kan worden gestart zonder het systeem opnieuw op te starten.

Kernelfuncties

De RTOS-kern zorgt voor de werking van het tussenliggende abstracte OS-niveau, dat voor de applicatiesoftware de bijzonderheden van het technische apparaat van de processor (meerdere processors) en de bijbehorende hardware verbergt.

Basisdiensten

Deze abstracte laag biedt vijf hoofdcategorieën van services voor applicatiesoftware.

• Taak beheer... De belangrijkste groep diensten. Stelt applicatieontwikkelaars in staat om softwareproducten te ontwerpen in de vorm van sets van afzonderlijke softwarefragmenten, die elk betrekking kunnen hebben op hun eigen onderwerpgebied, een afzonderlijke functie kunnen uitoefenen en een eigen tijdschijf kunnen krijgen voor werk. Elk zo'n fragment heet taak... Services in deze groep hebben de mogelijkheid om taken te starten en er prioriteiten aan toe te wijzen. De belangrijkste service is hier - Taakbeheer... Hij bewaakt de uitvoering van huidige taken, lanceert nieuwe taken binnen de juiste tijdsperiode en bewaakt de wijze van werken.
• Dynamische geheugentoewijzing... Veel (maar niet alle) RTOS-kernels ondersteunen deze groep services. Hiermee kunnen taken RAM-geheugen lenen voor tijdelijk gebruik in actieve toepassingen. Vaak gaan deze gebieden vervolgens van taak naar taak, en hierdoor wordt er snel een grote hoeveelheid gegevens tussen hen uitgewisseld. Sommige zeer kleine RTOS-kernels die zouden moeten worden gebruikt in hardware-omgevingen met een strikte geheugenlimiet, ondersteunen geen dynamische geheugentoewijzingsservices.
• Timerbediening... Omdat embedded systemen strikte eisen stellen aan de tijdframes voor het uitvoeren van taken, omvat de RTOS-kern een groep services die timerbeheer bieden om de tijdslimiet te volgen waarin een taak moet worden uitgevoerd. Deze services meten en stellen verschillende tijdsintervallen in (vanaf 1 μs en meer), genereren onderbrekingen wanneer tijdsintervallen zijn verstreken en creëren eenmalige en cyclische alarmen.
• Interactie tussen taken en synchronisatie... Diensten van deze groep stellen taken in staat om informatie uit te wisselen en de veiligheid ervan te waarborgen. Ze bieden ook de mogelijkheid voor programmafragmenten om hun werk op elkaar af te stemmen om de efficiëntie te verhogen. Als u deze services uitsluit van de RTOS-kern, beginnen de taken vervormde informatie uit te wisselen en kunnen ze de werking van aangrenzende taken verstoren.
• I/O-apparaatbewaking... Services in deze groep bieden een enkele programmeerinterface die samenwerkt met alle apparaatstuurprogramma's die typisch zijn voor de meeste embedded systemen.

Naast kernservices bieden veel RTOS-reeksen add-oncomponenten voor het organiseren van concepten op hoog niveau, zoals bestandssysteem, netwerken, netwerkbeheer, databasebeheer, grafische gebruikersinterface, enz. Hoewel veel van deze componenten veel groter zijn en complexer dan de RTOS-kern zelf, vertrouwen ze niettemin op zijn diensten. Elk van deze componenten wordt alleen in een embedded systeem opgenomen als de services ervan nodig zijn om de embedded applicatie uit te voeren en alleen om het geheugenverbruik tot een minimum te beperken.

Verschillen met besturingssystemen voor algemeen gebruik

Veel algemene besturingssystemen ondersteunen ook de bovenstaande services. Het belangrijkste verschil tussen RTOS-kernservices is echter: deterministisch gebaseerd op strikte tijdscontrole, de aard van hun werk. In dit geval betekent determinisme dat de uitvoering van één service van het besturingssysteem een ​​tijdsinterval van bekende duur vereist. Theoretisch kan deze tijd worden berekend met behulp van wiskundige formules, die strikt algebraïsch moeten zijn en geen tijdelijke parameters van willekeurige aard mogen bevatten. Elke willekeurige variabele die de uitvoeringstijd van een taak in een RTOS bepaalt, kan een ongewenste vertraging in de applicatie veroorzaken, dan past de volgende taak niet in zijn tijdschijf, wat een fout veroorzaakt.

In die zin zijn besturingssystemen voor algemene doeleinden niet deterministisch. Hun diensten kunnen willekeurige vertragingen in hun werk tolereren, wat kan leiden tot een vertraging in de reactie van de applicatie op gebruikersacties op een duidelijk onbekend tijdstip. Bij het ontwerpen van conventionele besturingssystemen richten ontwikkelaars zich niet op het wiskundige apparaat voor het berekenen van de uitvoeringstijd van een specifieke taak en service. Dit is niet kritisch voor dit soort systemen.

Taken plannen

Planner baan

De meeste RTOS'en voeren taakplanning uit op basis van het volgende diagram. Elke taak in de applicatie krijgt een bepaalde prioriteit toegewezen. Hoe hoger de prioriteit, hoe hoger de taakreactiviteit zou moeten zijn. Hoge reactiviteit wordt bereikt door de aanpak te implementeren prioriteit preventieve planning(preventieve prioriteitsplanning), waarvan de essentie is dat de planner de uitvoering van een taak op een willekeurig tijdstip mag stoppen als wordt bepaald dat een andere taak onmiddellijk moet worden gestart.

Het beschreven schema werkt volgens de volgende regel: als twee taken tegelijkertijd klaar zijn om te worden uitgevoerd, maar de eerste een hoge prioriteit heeft en de tweede een lage prioriteit, dan geeft de planner de voorkeur aan de eerste. De tweede taak wordt pas gestart nadat de eerste zijn werk heeft voltooid.

Het kan zijn dat er al een taak met een lage prioriteit is gestart en de planner een melding krijgt dat er een andere taak met een hogere prioriteit gereed is om te starten. Dit kan worden veroorzaakt door enige externe invloeden (onderbreking van de apparatuur), zoals het wijzigen van de status van de schakelaar van een apparaat dat wordt bestuurd door de RTOS. In een dergelijke situatie zal de taakplanner zich als volgt gedragen volgens de preventieve planningsbenadering. Een taak met een lage prioriteit mag de huidige montage-instructie voltooien (maar niet de instructie beschreven in de broncode van het programma in taal op hoog niveau), waarna de uitvoering van de taak wordt gestopt. Vervolgens wordt een taak met hoge prioriteit gelanceerd. Nadat het is verwerkt, start de planner de onderbroken eerste taak met de assembler-instructie die volgt op de laatst uitgevoerde taak.

Elke keer dat de taakplanner een signaal ontvangt over het optreden van een externe gebeurtenis (trigger), waarvan de oorzaak zowel hardware als software kan zijn, handelt het volgens het volgende algoritme.

1. Bepaalt of de momenteel actieve taak moet blijven worden uitgevoerd.
2. Stelt in welke taak als volgende moet beginnen.
3. Slaat de context van de gestopte taak op (zodat deze vervolgens kan worden hervat vanaf het punt waar deze was gestopt)
4. Stelt de context in voor de volgende taak.
5. Start deze taak.

Deze vijf stappen van het algoritme worden ook wel van taak wisselen.

De taak voltooien

In een conventionele RTOS kan een taak zich in 3 mogelijke toestanden bevinden:

1. De taak is in uitvoering;
2. De taak is gereed voor uitvoering;
3. De taak is geblokkeerd.

Meestal zijn de meeste taken geblokkeerd. Er kan slechts één taak tegelijk op de CPU worden uitgevoerd. In primitieve RTOS is de lijst met taken die klaar zijn voor uitvoering meestal erg kort, deze kan uit niet meer dan twee of drie items bestaan.

De belangrijkste functie van een RTOS-beheerder is het samenstellen van zo'n taakplanner.

Als er niet meer dan twee of drie taken in de lijst met kant-en-klare taken staan, wordt aangenomen dat alle taken zich in de optimale volgorde bevinden. Als zich situaties voordoen waarin het aantal taken in de lijst de toegestane limiet overschrijdt, worden de taken gesorteerd op prioriteit.

Planningsalgoritmen

Momenteel zijn twee benaderingen het meest intensief ontwikkeld om het probleem van effectieve planning in RTOS op te lossen.

• Statische planningsalgoritmen(RMS, Tarief Monotone Scheduling). Er wordt gebruik gemaakt van preventieve planning. Prioriteit wordt aan elke taak toegewezen voordat deze wordt uitgevoerd. Prioriteit wordt gegeven aan taken met de kortste doorlooptijden.
• Dynamische planningsalgoritmen(EDF, vroegste deadline eerste planning). Taken krijgen dynamisch prioriteit, waarbij prioriteit wordt gegeven aan taken met de vroegste start (eind) uitvoeringstijdslimiet.

Interactie tussen taken en het delen van bronnen

• Interrupts tijdelijk blokkeren
• Binaire semaforen
• Signalen verzenden

RTOS gebruikt meestal niet de eerste methode omdat de gebruikerstoepassing de processor niet zoveel kan besturen als hij wil. Veel embedded systemen en RTOS stellen je echter in staat om applicaties in kernelmodus uit te voeren om toegang te krijgen tot systeemaanroepen en controle te geven over de uitvoeringsomgeving zonder tussenkomst van het besturingssysteem.

Op uniprocessor-systemen is de beste oplossing een toepassing in de kernelmodus die onderbrekingen mag blokkeren. Terwijl de onderbreking is geblokkeerd, gebruikt de toepassing alleen de bronnen van het proces en kan geen enkele andere taak of onderbreking worden uitgevoerd. Op deze manier worden alle kritieke bronnen beschermd. Nadat de toepassing kritieke acties heeft voltooid, moet deze eventuele onderbrekingen deblokkeren. Tijdelijke onderbrekingsblokkering is alleen toegestaan ​​wanneer de langste kritieke uitvoeringstijd van de sectie korter is dan de toegestane onderbrekingsreactietijd. Meestal wordt deze beveiligingsmethode alleen gebruikt als de lengte van de kritieke code niet meer dan een paar regels is en geen lussen bevat. Deze methode is ideaal voor registerbeveiliging.

Wanneer de lengte van de kritieke sectie groter is dan het maximum of cycli bevat, moet de programmeur mechanismen gebruiken die identiek zijn of het gedrag van algemene systemen nabootsen, zoals semaforen en signalering.

Geheugentoewijzing

De volgende problemen met geheugentoewijzing krijgen meer aandacht in RTOS dan in algemene besturingssystemen.

Ten eerste de snelheid van geheugentoewijzing. Het standaard geheugentoewijzingsschema omvat het scannen van een lijst met niet-gespecificeerde lengte om een ​​vrij geheugengebied van een bepaalde grootte te vinden, wat onaanvaardbaar is, omdat in een RTOS geheugentoewijzing in een vaste tijd moet plaatsvinden.

Ten tweede kan het geheugen gefragmenteerd raken als de vrije delen ervan worden verdeeld door reeds lopende processen. Dit kan leiden tot de beëindiging van het programma vanwege het onvermogen om een ​​nieuw gedeelte van het geheugen te gebruiken. Een toewijzingsalgoritme dat geleidelijk de geheugenfragmentatie verhoogt, kan goed werken op desktopsystemen als ze minstens één keer per maand opnieuw opstarten, maar is onaanvaardbaar voor embedded systemen die jarenlang zonder herstart werken.

Een eenvoudig algoritme met vaste geheugenlengtes werkt heel goed in eenvoudige embedded systemen.

Dit algoritme werkt ook uitstekend op desktopsystemen, vooral wanneer tijdens de verwerking van een stuk geheugen door een kern, het volgende stuk geheugen wordt verwerkt door een andere kern. Desktop-geoptimaliseerde RTOS's zoals het Unison-besturingssysteem of DSPnano RTOS bieden deze mogelijkheid.

Realtime besturingssystemen (lijst)

Opgemerkt moet worden dat de lijst geen systemen bevat die in de USSR zijn ontwikkeld voor militaire en ruimtesystemen - om voor de hand liggende redenen die verband houden met het geheimhoudingsregime. Hun bestaan ​​en gebruik gedurende tientallen jaren is echter een onbetwistbaar feit waarmee rekening moet worden gehouden.

Notities (bewerken)

Literatuur

• Zyl S. Realtime besturingssysteem QNX: van theorie naar praktijk. - 2e druk. - SPb. : BHV-Petersburg, 2004 .-- 192 d. - ISBN 5-94157-486-X
• Zyl S. QNX-momenten. Basis van toepassing. - SPb. : BHV-Petersburg, 2004 .-- 256 d. - ISBN 5-94157-430-4
• Curten R. Inleiding tot QNX / Neutrino 2. - SPb. : Petropolis, 2001 .-- 512 p. - ISBN 5-94656-025-9
• Oslander D.M., Ridgley J.R., Ringenberg J.D. Besturingsprogramma's voor mechanische systemen: Objectgericht ontwerpen van realtime systemen. - M.: Binom. Kennislaboratorium, 2004 .-- 416 p. - ISBN 5-94774-097-4

Links

• Overzicht van realtime besturingssystemen

Ministerie van Onderwijs en Wetenschappen van de Russische Federatie

Volga State Technological University

Discipline abstract

"Realtime besturingssystemen: functies en toepassingen"

Voltooid: student van EF (groep PI-12)

Mikusjov Yu.V.

[e-mail beveiligd]

Docent: Borodin A.V.

Yoshkar-Ola

● Inleiding

● Definitie

● Ontwikkeling van moderne besturingssystemen

● Huidige staat van het onderwerpgebied

● Verschillen met besturingssystemen voor algemeen gebruik

● RTOS-architectuur

● Soorten OS-taken

● Vijf belangrijkste onzichtbare taken van het besturingssysteem

● Functies

●Toepassing

● Markt voor besturingssystemen

● De toekomst van RTOS

● Conclusie

● Lijst met gebruikte bronnen

Invoering

Realtime besturingssystemen (RTOS) zijn ontworpen om een ​​interface te bieden voor de bronnen van tijdkritische realtimesystemen. De hoofdtaak in dergelijke systemen is de tijdigheid van de gegevensverwerking.

De belangrijkste vereiste voor RTOS is de vereiste om ervoor te zorgen: voorspelbaarheid of determinisme het gedrag van het systeem in de slechtste externe omstandigheden, dat sterk verschilt van de prestatie- en snelheidsvereisten van algemene besturingssystemen. Een goede RTOS heeft voorspelbaar gedrag onder alle opstartscenario's (gelijktijdige interrupts en thread-uitvoering).

Er is een verschil tussen realtime systemen en embedded systemen. Een embedded systeem hoeft niet altijd voorspelbaar gedrag te vertonen, in dat geval is het geen realtime systeem. Zelfs een snelle blik op mogelijke ingebedde systemen suggereert echter dat de meeste ingebedde systemen voorspelbaar gedrag nodig hebben, althans voor bepaalde functionaliteit, en daarom kunnen deze systemen worden geclassificeerd als realtime systemen.

Het is gebruikelijk om onderscheid te maken tussen zachte en harde realtime systemen. In harde real-time systemen leidt het onvermogen om een ​​reactie te geven op gebeurtenissen op een bepaald moment tot storingen en de onmogelijkheid om de toegewezen taak te voltooien. In de meeste Russischtalige literatuur worden dergelijke systemen systemen met deterministische tijd genoemd. In praktische toepassingen moeten reactietijden tot een minimum worden beperkt. Systemen die niet onder de definitie van "hard" vallen, worden zachte realtime-systemen genoemd. er is nog steeds geen duidelijke definitie voor in de literatuur. Zachte real-time systemen hebben misschien geen tijd om het probleem op te lossen, maar dit leidt niet tot systeemstoringen als geheel. In real-time systemen is het noodzakelijk om een ​​bepaalde regieperiode in te voeren (in de Engelstalige literatuur - deadline), vóór het verstrijken waarvan de taak noodzakelijkerwijs (voor zachte real-time systemen - bij voorkeur) voltooid moet zijn. Deze deadline wordt door de taakplanner gebruikt om zowel een prioriteit toe te kennen aan een taak wanneer deze begint als bij het kiezen van een taak om uit te voeren.

definities

Een realtime systeem is een type besturingssysteem met als hoofddoel het bieden van de noodzakelijke en voldoende set functies die softwareontwikkeling van realtimesystemen op specifieke hardware mogelijk maken.

Een systeem wordt een realtime systeem genoemd als de juistheid van zijn werking niet alleen afhangt van de logische juistheid van berekeningen, maar ook van de tijd waarin deze berekeningen worden uitgevoerd. Dat wil zeggen, voor gebeurtenissen die in een dergelijk systeem plaatsvinden, is het moment waarop deze gebeurtenissen plaatsvinden even belangrijk als de logische juistheid van de gebeurtenissen zelf.

Realtime systeemcomponenten.

Mac OS X-decodering:

"Mac" verwijst naar de naam van het Macintosh-bedrijf.

"OS" staat voor besturingssysteem, dat wil zeggen het besturingssysteem.

"X" - Romeins cijfer tien, betekent het versienummer van het besturingssysteem.

Ontwikkeling van moderne besturingssystemen

Bij de ontwikkeling van moderne besturingssystemen is er een tendens om de code verder naar de hogere niveaus te verplaatsen en alles wat mogelijk is uit de kernelmodus te verwijderen, waardoor er een minimale microkernel overblijft. Dit wordt meestal gedaan door de meeste taken van het besturingssysteem te verplaatsen naar gebruikersprocessen.

Wanneer een gebruikersproces (nu een serviceproces of clientproces genoemd) een verzoek voor een bewerking ontvangt, zoals het lezen van een blok van een bestand, stuurt het het verzoek naar het serverproces (serviceproces), dat het verwerkt en een reactie terugstuurt .

Door het besturingssysteem op te delen in delen, die elk slechts één element van het systeem beheren (bestandssysteem, processen, terminal of geheugen), zijn alle delen klein en beheersbaar.

Bovendien hebben alle servers geen directe toegang tot hardware, aangezien alle servers in de gebruikersmodus draaien in plaats van in de kernelmodus. Als er dus een fout optreedt op de bestandsserver, kan de bestandsaanvraagservice worden vernietigd, maar dit brengt meestal niet de hele machine tot stilstand.

Een ander voordeel van het client-servermodel is de gemakkelijke aanpassing voor gebruik in gedistribueerde systemen. Als een client met een server communiceert door er berichten naar te sturen, hoeft de client niet te weten of het bericht lokaal op zijn eigen machine wordt verwerkt of dat het via het netwerk naar een server op een externe machine is verzonden. Vanuit het oogpunt van de klant gebeurt in beide gevallen hetzelfde: er is een verzoek verzonden en een reactie ontvangen.

Het verhaal hierboven over de kernel die de berichtenstroom van clients naar servers en terug afhandelt, is niet helemaal realistisch. Sommige functies van het besturingssysteem, zoals het laden van instructies in fysieke I/O-registers, zijn moeilijk, zo niet onmogelijk, uit te voeren vanuit programma's in de gebruikersruimte. Er zijn twee manieren om dit probleem op te lossen.

De eerste is dat sommige kritieke serverprocessen (bijvoorbeeld I/O-apparaatstuurprogramma's) feitelijk in de kernelmodus worden uitgevoerd, met volledige toegang tot de hardware, maar communiceren met andere processen via het gebruikelijke berichtenschema.

De tweede manier is om een ​​minimaal informatieverwerkingsmechanisme in de kernel te bouwen, maar de politieke besluitvorming over te laten aan de servers in de gebruikersruimte. De kernel kan bijvoorbeeld berichten herkennen die naar specifieke adressen zijn verzonden. Voor de kernel betekent dit dat je de inhoud van het bericht moet nemen en het bijvoorbeeld in de I / O-registers van een schijf moet laden om een ​​schijfleesbewerking te starten.

In dit voorbeeld zou de kernel de berichtbytes misschien niet eens kunnen onderzoeken als ze geldig of zinvol waren; het kan ze blindelings naar schijfregisters kopiëren. (Het is duidelijk dat er een schema moet worden gebruikt om de reeks processen te beperken die dergelijke berichten mogen verzenden).

De huidige staat van het onderwerpgebied

Verenigingen, bedrijven en producten

Microsoft en Apple Inc. zijn de meest populaire fabrikanten van besturingssystemen en software voor hen in de moderne wereld.

Moderne besturingssystemen van Microsoft:

Windows XP (Windows NT 5.1)

Windows Vista (Windows NT 6.0)

Windows 7 (Windows NT 6.1)

Windows 8 (Windows NT 6.2)

Windows 10 (Windows NT 10)

Moderne besturingssystemen van Apple Inc:

Moderne mobiele besturingssystemen:

1. Linux-systemen (Android)

Verschillen met besturingssystemen voor algemeen gebruik

Het belangrijkste verschil tussen de kerndiensten van RTOS is de deterministische aard van hun werk op basis van strikte tijdscontrole. In dit geval betekent determinisme dat de uitvoering van één service van het besturingssysteem een ​​tijdsinterval van bekende duur vereist. Theoretisch kan deze tijd worden berekend met behulp van wiskundige formules, die strikt algebraïsch moeten zijn en geen tijdelijke parameters van willekeurige aard mogen bevatten. Elke willekeurige variabele die de uitvoeringstijd van een taak in een RTOS bepaalt, kan een ongewenste vertraging in de werking van de applicatie veroorzaken, dan past de volgende taak niet in zijn tijdschijf, wat een fout zal veroorzaken.

In die zin zijn besturingssystemen voor algemene doeleinden niet deterministisch. Hun diensten kunnen willekeurige vertragingen in hun werk tolereren, wat kan leiden tot een vertraging in de reactie van de applicatie op gebruikersacties op een duidelijk onbekend tijdstip. Bij het ontwerpen van conventionele besturingssystemen richten ontwikkelaars zich niet op het wiskundige apparaat voor het berekenen van de uitvoeringstijd van een specifieke taak en service. Dit is niet kritisch voor dit soort systemen.

RTOS-architectuur

Tijdens zijn geschiedenis heeft de architectuur van besturingssystemen een aanzienlijke ontwikkeling doorgemaakt. Een van de eerste bouwprincipes, de zogenaamde. monolithische OS (Figuur 1), was om het OS weer te geven als een set modules die op verschillende manieren met elkaar interageren binnen de systeemkernel en applicatieprogramma's voorzien van invoerinterfaces voor toegang tot hardware. Het belangrijkste nadeel van deze architectuur is de slechte voorspelbaarheid van het gedrag, veroorzaakt door de complexe interactie van systeemmodules met elkaar.

De meeste moderne besturingssystemen, zowel realtime als voor algemeen gebruik, zijn echter op dit principe gebouwd.

Bij automatiseringstaken worden gelaagde besturingssystemen veel gebruikt als RTOS (Afbeelding 2). Het bekende MS-DOS-systeem is een voorbeeld van zo'n OS. In systemen van deze klasse konden applicatietoepassingen niet alleen toegang krijgen tot hardware via de systeemkernel of zijn residente services, maar ook rechtstreeks. RTOS is jarenlang op dit principe gebouwd. Vergeleken met monolithische besturingssystemen biedt deze architectuur een veel grotere mate van voorspelbaarheid van systeemreacties en stelt applicatietoepassingen ook in staat snel toegang te krijgen tot hardware. Het nadeel van dergelijke systemen is het ontbreken van multitasking. In deze architectuur werd het probleem van het verwerken van asynchrone gebeurtenissen teruggebracht tot het bufferen van berichten en het vervolgens opeenvolgend pollen van de buffers en verwerking. Tegelijkertijd werd de naleving van de kritische servicevoorwaarden verzekerd door de hoge snelheid van het rekencomplex in vergelijking met de snelheid van externe processen.

Een van de meest effectieve architecturen voor het bouwen van realtime besturingssystemen is de client-server-architectuur. Het algemene schema van het besturingssysteem dat op deze technologie werkt, wordt getoond in figuur 3. Het belangrijkste principe van deze architectuur is om OS-services in de vorm van servers naar het gebruikersniveau te brengen, en de microkernel vervult de functies van een berichtverzender tussen clientgebruiker programma's en servers - systeemdiensten. Deze architectuur biedt veel voordelen op het gebied van vereisten voor RTOS en embedded systemen. Deze voordelen omvatten:

1. De betrouwbaarheid van het besturingssysteem neemt toe, aangezien elke service is in feite een op zichzelf staande applicatie en het is gemakkelijker om fouten te debuggen en op te sporen.

2. Zo'n systeem schaalt beter, omdat onnodige services uit het systeem kunnen worden uitgesloten zonder dat dit ten koste gaat van de prestaties.

3. Verhoogt de fouttolerantie van het systeem, omdat: Een bevroren service kan opnieuw worden gestart zonder het systeem opnieuw op te starten.

Helaas worden tegenwoordig niet veel besturingssystemen op client-serverbasis geïmplementeerd. Tot de bekende RTOS-implementerende microkernel-architectuur behoren OS9 en QNX.

Soorten taken

Elk proces bevat een of meer taken. Het besturingssysteem zorgt ervoor dat een taak nieuwe taken kan voortbrengen. Taken in hun manier van handelen kunnen worden onderverdeeld in 3 categorieën.

1. Cyclische taken. Typisch voor besturings- en interactieve processen.

2. Periodieke taken. Ze zijn typerend voor veel technologische processen en synchronisatietaken.

3. Impulstaken. Typisch voor signaleringstaken en asynchrone technologische processen.

De vijf belangrijkste onzichtbare taken van het besturingssysteem

1. Biedt hardware-software "grip"

Het besturingssysteem fungeert als een soort "vertaler" tussen de hardware van de computer en zijn software. Als je de computerkast opent, zie je verschillende borden, chips, kabels en andere componenten. Het is de fysieke basis die de uitvoering van het programma mogelijk maakt. Maar het programma kan niet zomaar de hardwarebronnen van de computer overnemen en gebruiken. Het doet dit via het besturingssysteem.

De laatste tijd worden besturingssystemen steeds vaker 'platforms' genoemd. En deze naam geeft heel nauwkeurig de essentie weer. Het besturingssysteem is het platform waarop de programma's zich bevinden. Of, zoals ze nu zeggen, toepassingen op het besturingssysteem. Het is het besturingssysteem waarmee de software kan "communiceren" met de hardware. Dit geldt ook voor invoer- en uitvoerapparaten. Het eenvoudigste voorbeeld van een invoerapparaat is een toetsenbord en een uitvoerapparaat is een monitor.

Dit is een zeer belangrijke taak. In theorie kunnen honderden verschillende invoer- en uitvoerapparaten op één computer worden aangesloten. Laten we een gewone muis nemen. Maar "muis" is een algemeen begrip. Er zijn tientallen verschillende modellen van deze manipulator. Het zou een ontmoedigende taak zijn om voor elk type muis afzonderlijke softwareondersteuning te bieden, zodat deze rechtstreeks "communiceert" met de bronnen van de computer. Maar de output is de driverbasis in het besturingssysteem. Voor de gebruiker lijkt het alsof hij zomaar een muis op zijn computer heeft aangesloten, en ze pakte hem meteen aan en begon te werken.

2. Laat dezelfde applicatie op verschillende hardware draaien

Het is het besturingssysteem waarmee de software op verschillende computers kan worden uitgevoerd, niet slechts op één specifieke configuratie. Er waren eens programma's geschreven voor een specifiek computermodel. De programmeertaal speelde eigenlijk de rol van het besturingssysteem van de voorlopers van moderne pc's, microcomputers van eind jaren zeventig van de vorige eeuw.

Maar tegenwoordig heeft het besturingssysteem de rol van een soort "adapter" tussen programma's en computerhardware op zich genomen. Als we twee computermodellen nemen, zullen de sets componenten waaruit ze zijn samengesteld verschillen. Dit geldt zelfs voor de bekende "Macintosh" die bekend staat om hun onderlinge gelijkenis, om nog maar te zwijgen van de enorme variëteit die te vinden is op de moderne pc-markt.

De besturingsomgeving creëert een zogenaamde abstracte omgeving voor het programma. Dit kan worden gezien als een dialoog tussen het besturingssysteem en het programma. Tijdens dit "gesprek" dat voor een persoon onbegrijpelijk is, "vertelt" het programma het platform over zijn behoeften en moet het besturingssysteem "denken" over hoe het rationeel kan worden bevredigd. Het punt is dat je heel snel moet denken. De moderne gamer is niet klaar om een ​​uur of twee te wachten voordat zijn favoriete game is geladen.

Het programma "vertelt" het besturingssysteem dus wat het precies nodig heeft om correct te werken. De applicatie is immers direct onbekend met de middelen van een computer. En het besturingssysteem verdeelt op zijn beurt de taken die eraan zijn toegewezen door het programma tussen de bronnen van het digitale apparaat. En het type hardware maakt niet uit voor het programma. Het platform regelt alles! Het besturingssysteem kan "praten", zo niet met alle, dan met heel veel apparaten en hardwaremodules.

Zonder deze waardevolle vaardigheid van het besturingssysteem zouden programmeurs hun programma's moeten herschrijven voor elke specifieke configuratie van de computer, voor elke set componenten. En als het niet voor het besturingssysteem is, werkt het programma misschien helemaal niet op een computer, waarvan de kenmerken verschillen van die door de programmeur bij het maken van het programma.

Ontwikkelaars bouwen tegenwoordig hun applicaties voor platforms, niet voor een bekende hardwareconfiguratie. Simpel gezegd, niet voor een specifieke computer, maar voor een specifiek besturingssysteem. Dit is natuurlijk veel makkelijker. Miljoenen apparaten kunnen op hetzelfde besturingssysteem draaien. Daarom zijn tien- en zelfs honderdduizenden toepassingen mogelijk geworden, beschikbaar voor de moderne gebruiker van elk van de populaire platforms.

3. Zoek naar het bestand dat vereist is voor de toepassing

De fysieke middelen van een computer alleen zouden niet voldoende zijn voor programma's om hun taken correct uit te voeren. Alle informatie wordt opgeslagen in bestanden en deze bestanden moeten aan bepaalde regels voldoen. Deze regels hebben betrekking op het benoemen en opslaan van bestanden. We noemen deze algemene set regels het "bestandsbeheersysteem" of gewoon "bestandsbeheer".

Verschillende besturingssystemen hanteren verschillende benaderingen voor het beheren van bestanden. Bovendien kan de gebruiker extra software installeren waarmee hij bestanden efficiënter kan beheren. Het is het besturingssysteem dat de bestanden "onthoudt" die op de computer zijn opgeslagen. Wanneer een toepassing toegang wil tot een bepaald bestand, wijst het besturingssysteem het programma de weg ernaartoe.

Zonder een bestandsbeheersysteem is digitale informatie op een computer slechts een zinloze verzameling gegevens. Een chaos waarin niets te vinden is. En nog meer om in de kortste fractie van een seconde te vinden.

Het besturingssysteem volgt onzichtbaar zijn regels, zodat u niet handmatig die geheugencellen hoeft te openen waar het bestand dat u nodig heeft fysiek is opgeslagen. Maar het belangrijkste is dat de gebruiker van een modern besturingssysteem deze regels niet hoeft te kennen om op een computer te kunnen werken.

4. Efficiënte toewijzing van beschikbaar RAM-geheugen

Aangezien we het over geheugen hebben, is het logisch om te onthouden over RAM (RAM, RAM). Over de opslag die altijd "bij de hand" is door de processor.

Benadrukt moet worden dat het besturingssysteem ook deze belangrijkste computerbron beheert. RAM is een sterk onderschatte bron door veel gebruikers. Hoe u uw computer sneller kunt laten werken? Velen geloven dat ze dringend een krachtigere processor nodig hebben. Maar in de praktijk is het vaak voldoende om simpelweg de hoeveelheid RAM te vergroten om een ​​significante verbetering van de computerprestaties te voelen.

In RAM plaatst de computer de informatie die nodig kan zijn voor de processor die de berekeningen uitvoert. Beschouw dit type geheugen gewoon als een tijdelijke opslag van informatie die "dichter bij de processor" zou moeten zijn.

Als we met een computer werken, hebben we soms meerdere programma's tegelijk draaien. Het besturingssysteem wijst een bepaalde hoeveelheid geheugen toe aan elke taak. Als de processor informatie nodig heeft die hij niet in het RAM kan vinden, zal hij ergens anders moeten zoeken. Met name op de harde schijf van de computer. Het duurt langer dan het extraheren van gegevens uit het RAM. Voor de gebruiker zal deze situatie eruitzien als een tijdelijke "bevriezing" van de applicatie. In dergelijke gevallen is het gebruikelijk om te zeggen dat 'de computer denkt'.

Een van de taken die het besturingssysteem onzichtbaar voor de gebruiker op zich neemt, is het minimaliseren van de latentietijd, dat wil zeggen de zeer onaangename tijd waarin de computer bezig is met zijn eigen zaken en niet reageert op uw oproepen. Het probleem is dat op elk moment het besturingssysteem

heeft een bepaalde hoeveelheid RAM, die altijd beperkt is. Dit bedrag is onder andere afhankelijk van hoeveel programma's je tegelijkertijd hebt opgestart. Het besturingssysteem moet op elk moment "weten" hoeveel RAM het nog in voorraad heeft om het op tijd toe te wijzen aan een proces dat deze belangrijke hulpbron nodig heeft.

Het besturingssysteem "evalueert" de vereisten van elk lopend proces en beslist hoe hieraan redelijkerwijs kan worden voldaan. Idealiter zou dit zo moeten gebeuren dat de gebruiker helemaal geen vertraging ervaart. Maar in de praktijk probeert het besturingssysteem dergelijke vertragingen eenvoudig tot een minimum te beperken door de middelen die het daadwerkelijk heeft rationeel toe te wijzen.

Er zijn geen computers op aarde met onbeperkt RAM. Het systeem moet daarom altijd kiezen welk proces op een bepaald moment als prioriteit wordt beschouwd en welk proces secundair is. Aan wie het dringend is om geheugen toe te wijzen, en wie het voorlopig zal volhouden en geduldig zal zijn. De gebruiker is het mogelijk niet altijd eens met de regels die gelden voor het besturingssysteem bij het toewijzen van geheugen. Maar het zou veel moeilijker en langer zijn om onafhankelijk RAM-geheugen toe te wijzen aan processen dan om het aan het softwareplatform toe te vertrouwen.

5. Vestigt de aandacht van de processor op een bepaalde taak

De centrale verwerkingseenheid (CPU) is de fysieke module die de taken oplost die de gebruiker voor zijn computer instelt. Een ander ding is dat een zeldzame gebruiker de taal spreekt die de processor verstaat. Wat is er, zelfs niet elke programmeur is bekend met machinecode. Een persoon denkt misschien niet eens na over het feit dat een programma een complexe reeks wiskundige problemen is.

De centrale processor doet de berekeningen, dat wil zeggen, het vindt een oplossing voor deze problemen, en het geeft je kant-en-klare resultaten die niet eens in de buurt komen van de formules uit het algebra-leerboek. De gemiddelde gebruiker is gewoon niet geïnteresseerd in al deze wiskunde. Hij wil dat zijn speelbare personage in een fractie van een seconde over een obstakel springt, of hij wil de spelling controleren van de tekst die hij zojuist heeft geschreven. Achter deze schijnbaar verre van saaie getallen gaat de meest complexe wiskunde schuil.

Elk programma dat draait, vereist een fractie van de rekenkracht van de processor. Hoe meer programma's u tegelijkertijd uitvoert, hoe dichter de processorbelasting maximaal is. De taak van het besturingssysteem is om de aanlevering van informatie voor verwerking aan de processor te coördineren, zodat alles soepel en onzichtbaar voor de gebruiker verloopt. Het besturingssysteem kan de aandacht van de processor van de ene taak naar de andere verplaatsen.

Een van de belangrijke rollen van een besturingssysteem is die van een resourcemanager. Als het deze taak goed aankan, weten we niet eens op welk moment de processor de ene taak opzij zette en zijn aandacht op de andere richtte.

Onzichtbare en onvervangbare assistent

De moeilijkste van alle taken voor een besturingssysteem is om het te negeren en je te concentreren op de applicaties die je interesseren. En terwijl alles goed gaat, denkt de gebruiker helemaal niet aan het platform. En pas wanneer softwarefouten beginnen, realiseert de gebruiker zich hoe belangrijk de missie van het besturingssysteem is.

Die "verschillen" tussen besturingssystemen die voor de meeste gebruikers merkbaar zijn, zijn puur cosmetisch. Het komt zelden voor dat een gebruiker de programmering voldoende begrijpt om achter de schil van een grafische interface te zien wat het ene besturingssysteem daadwerkelijk van het andere onderscheidt. Noch het uiterlijk van het bureaublad, noch het ontwerp van de app-pictogrammen hebben iets te maken met de intrinsieke aard van het besturingssysteem.

De hierboven beschreven taken worden op de een of andere manier door elk uitgevoerd modern besturingssysteem die elk computerapparaat bestuurt. Ongeacht hoe het besturingssysteem eruitziet en op welk apparaat het is geïnstalleerd: op een pc, mobiel apparaat of gameconsole.

Eigenaardigheden

Positieve eigenschappen

Wijdverbreide productbeschikbaarheid

In de overgrote meerderheid van de gevallen is Windows OS op computers geïnstalleerd. Daarom kunt u, als u een vriend of uw werk bent komen bezoeken, gemakkelijk een paar foto's, tekstbestanden of clips van een flashstation overzetten. Gebruiksgemak en ondersteuning voor Windows OC van alle hardware en software die hebben bijgedragen aan de wereldwijde distributie van deze OC.

Leuke interface

Moderne OC's hebben een mooie en eenvoudige interface. Dit draagt ​​bij aan het snel waarnemen van informatie, gebruiksgemak van de computer, snel leren werken met het besturingssysteem.

OS-stabiliteit

Over het algemeen is de stabiliteit van de moderne OC acceptabel te noemen. Het woord "aanvaardbaar" moet hier echter vergezeld gaan van een groot aantal kwalificaties:

1. Aanvaardbare stabiliteit van het besturingssysteem wordt pas na zijn hoogwaardige en competente afstemming - het is niet nodig om hier te praten over een niet-geconfigureerd systeem (evenals een niet-geconfigureerde gitaar).

2. De stabiliteit van een modern besturingssysteem hangt ook grotendeels af van de versie van het product en de aanwezigheid van geïnstalleerde servicepacks en add-ons - helaas, zonder hun aanwezigheid crasht het besturingssysteem vaak.

3. De stabiliteit van het besturingssysteem hangt ook af van de toepassingen zelf die door de gebruiker op het besturingssysteem zijn geïnstalleerd: hoe stabieler ze in gebruik zijn en hoe beter compatibel met de Windows-softwareschil zelf, hoe minder storingen we zullen kunnen waarnemen in de werking van het hoofdbesturingssysteem.

4. De stabiliteit van het moderne besturingssysteem wordt sterk beïnvloed door de hardware zelf, die wordt gebruikt in combinatie met het draaiende besturingssysteem.

5. Ook hebben device drivers invloed op de stabiele werking van een moderne OC. Deze miniprogramma's zijn verantwoordelijk voor het koppelen van bepaalde software aan bepaalde hardware.

Goede compatibiliteit met producten van verschillende ontwikkelaars (ongeveerOC ramen)

Moderne OC is in staat om alle bestandstypen die in zijn vroege reïncarnaties verschenen, correct te begrijpen. Als u zich dezelfde bestandsextensies herinnert, wordt het duidelijk dat hun voorouder in feite hetzelfde primitieve en archaïsche besturingssysteem is, ooit gekocht van een externe ontwikkelaar en in gedachten gebracht door Microsoft - MS-DOS. Deze continuïteit van bestandsformaten loopt als een rode draad door alle versies van Windows, wat op zich al geweldig is.

Real Time OS (RTOS) is een OS dat een bepaalde capaciteit binnen een bepaald tijdsbestek garandeert. Het kan bijvoorbeeld worden ontworpen om aan te geven dat een object op een lopende band beschikbaar is gekomen voor een robot. Dergelijke omhulsels worden geclassificeerd als "hard" en "zacht".

Starre besturingssystemen in realtime gaan ervan uit dat de berekening niet kan worden uitgevoerd als het object niet binnen de opgegeven periode beschikbaar is (een dergelijke bewerking zal mislukken).

In een soft operating system blijft de lopende band in realtime onder deze omstandigheden functioneren, maar kan het productievolume lager zijn doordat de objecten niet op het afgesproken tijdstip beschikbaar kunnen zijn, waardoor de robot tijdelijk onproductief zal zijn.

Voordat u voorbeelden geeft van realtime besturingssystemen, moet u de specifieke kenmerken van hun gebruik begrijpen. Sommige van deze besturingssystemen zijn gemaakt voor speciale toepassingen, andere voor meer algemene doeleinden. Bovendien worden sommige shells voor algemene doeleinden soms ook gebruikt voor real-time operatie. Hoe de bekende Windows 2000 of IBM Microsoft/390 zich van dit type kan gedragen. Dat wil zeggen, zelfs als het besturingssysteem niet aan enkele van de vereisten voldoet, kan het kenmerken hebben die het mogelijk maken om het in realtime als een oplossing voor een specifiek toepassingsprobleem te beschouwen.

Voorbeelden van besturingssystemen en hun kenmerken

Over het algemeen heeft realtime de volgende kenmerken:

• Multitasking.
• Technologische stromen die kunnen worden geprioriteerd.
• Voldoende aantal interruptniveaus.

Realtime besturingssystemen worden vaak gebruikt als onderdeel van kleine embedded shells die worden gebruikt in micro-apparaatformaat. Sommige kernels kunnen dus in realtime worden gezien als besturingssystemen met één taak (voorbeelden: kernels als onderdeel van IOS, Android, enz.). Ze hebben echter andere apparaatcomponenten nodig, zoals stuurprogramma's, om hun toegewezen taken uit te voeren. Daarom is een volwaardige in de regel meer dan alleen een kernel.

Een typisch voorbeeld van een RTOS-toepassing is een HDTV-ontvanger en -beeldscherm. Het moet het digitale signaal lezen, decoderen en weergeven als inkomende gegevens. Elke vertraging zal merkbaar zijn als gepixelde video en/of vervormde audio.

Tegelijkertijd, wanneer het verzoek wordt gedaan "geef voorbeelden van besturingssystemen van dit type", wordt de vermelding van de meest bekende namen geïmpliceerd. Wat zit er in deze groep?

VxWorks van WindRiver

VxWorks is een realtime besturingssysteem dat door WindRiver is ontwikkeld als propriëtaire software. VxWorks werd voor het eerst uitgebracht in 1987 en was oorspronkelijk bedoeld voor gebruik in embedded systemen die realtime en deterministische prestaties vereisen. Voorbeelden van dit type besturingssystemen worden dus gebruikt op het gebied van beveiliging en veiligheid, verschillende industrieën (met name lucht- en ruimtevaart en defensie), de productie van medische apparaten, industriële apparatuur, robotica, energie, transportbeheer, netwerkinfrastructuur, verbetering van de automobielindustrie en consumentenelektronica.

VxWorks ondersteunt Intel (x86, inclusief de nieuwe IntelQuarkSoC en x86-64), MIPS, PowerPC, SH-4 en ARM-architectuur. Deze RTOS wordt geleverd met een krachtige kernel, middleware, ondersteuning voor betaalde add-ons en hardwaretechnologieën van derden. In de nieuwste release, VxWorks 7, is het systeem opnieuw ontworpen voor modulariteit en upgrade, waarbij de OS-kernel gescheiden blijft van middleware, applicaties en andere pakketten.

QNX Neutrino

Ook klassieke voorbeelden van besturingssystemen van dit type zijn enkele Unix-achtige shells. Dit is QNX Neutrino, oorspronkelijk ontwikkeld in de vroege jaren 80 door het Canadese bedrijf Quantum Software Systems. Uiteindelijk werd de ontwikkeling in 2010 overgenomen door BlackBerry. QNX is een van de eerste commercieel succesvolle microkernel-besturingssystemen, die wordt gebruikt in een verscheidenheid aan apparaten, waaronder auto's en mobiele telefoons.

FreeRTOS

FreeRTOS is een populair realtime kernelbesturingssysteem voor embedded apparaten dat is geladen met 35 microcontrollers. Het wordt gedistribueerd onder de GPL met aanvullende beperkingen en optionele uitzonderingen. De beperking verbiedt benchmarking, terwijl de uitsluiting toestaat dat de eigen code van de gebruiker naast closed source wordt gebruikt, terwijl de kernel zelf behouden blijft. Dit maakt het makkelijker om FreeRTOS in je eigen applicaties te gebruiken.

Windows CE

Windows Embedded Compact is een subfamiliebesturingssysteem dat door Microsoft is ontwikkeld als onderdeel van de Windows Embedded-productfamilie. In tegenstelling tot de Windows Embedded Standard, die is gebaseerd op Windows NT, gebruiken deze voorbeeldbesturingssystemen een exclusieve hybride kernel. Microsoft verleent Windows CE-licenties aan OEM's die hun eigen gebruikersinterfaces kunnen wijzigen en maken, en leggen hiervoor de technische basis.

Onderscheidende kenmerken van RTOS versus algemene besturingssystemen

Besturingssystemen voor algemene doeleinden, met name besturingssystemen voor meerdere gebruikers zoals UNIX, zijn gericht op de optimale verdeling van computerbronnen tussen gebruikers en taken. In realtime besturingssystemen verdwijnt zo'n taak naar de achtergrond - alles verdwijnt voor de hoofdtaak - om tijd te hebben om te reageren op gebeurtenissen die zich in de faciliteit voordoen. Een ander verschil is dat het gebruik van een realtime besturingssysteem altijd gepaard gaat met apparatuur, met de faciliteit, met gebeurtenissen die plaatsvinden in de faciliteit. Het realtime besturingssysteem is gericht op het afhandelen van externe gebeurtenissen. Een realtime besturingssysteem kan qua gebruikersinterface vergelijkbaar zijn met een algemeen besturingssysteem, maar het is op een heel andere manier ontworpen en de toepassing van realtime besturingssystemen is altijd specifiek. Als een algemeen besturingssysteem door gebruikers (niet ontwikkelaars) doorgaans wordt gezien als een kant-en-klare set applicaties, dan dient een realtime besturingssysteem alleen als een hulpmiddel voor het creëren van een specifiek realtime hardware- en softwarecomplex. En daarom zijn de meeste gebruikers van realtime besturingssystemen ontwikkelaars van realtimecomplexen, mensen die besturingssystemen en gegevensverzameling ontwerpen. Bij het ontwerpen en ontwikkelen van een specifiek real-time systeem, weet de programmeur altijd precies welke gebeurtenissen zich in de faciliteit kunnen voordoen, kent hij de kritieke timing van het onderhoud van elk van deze gebeurtenissen. Het RT-systeem moet tijd hebben om te reageren op een gebeurtenis die zich heeft voorgedaan op de locatie faciliteit binnen een tijd die cruciaal is voor dit evenement. De kritieke tijd voor elke gebeurtenis wordt bepaald door het object en de gebeurtenis zelf en kan verschillen, maar de reactietijd van het systeem moet worden voorspeld (berekend) wanneer het systeem wordt gemaakt. Gebrek aan reactie op het voorspelde tijdstip wordt voor realtime systemen als een fout beschouwd. Het systeem moet kunnen reageren op gelijktijdig optredende gebeurtenissen. Zelfs als twee of meer externe gebeurtenissen tegelijkertijd plaatsvinden, moet het systeem erin slagen om op elk van hen te reageren gedurende de tijdsintervallen die cruciaal zijn voor deze gebeurtenissen.

Harde en zachte realtime systemen

Er zijn twee soorten realtimesystemen: harde realtimesystemen en zachte realtimesystemen.

Harde real-time systemen staan ​​onder geen enkele voorwaarde vertragingen toe in de reactie van het systeem, aangezien:

• resultaten kunnen nutteloos zijn als u te laat bent
• een catastrofe kan optreden als de reactie wordt vertraagd

• de kosten van te laat komen kunnen oneindig hoog zijn.

Voorbeelden van harde real-time systemen zijn controlesystemen aan boord, noodbeveiligingssystemen, noodgebeurtenisrecorders.

Zachte realtime-systemen worden gekenmerkt door het feit dat de responsvertraging niet kritisch is, hoewel dit kan leiden tot een verhoging van de kosten van resultaten en een afname van de prestaties van het systeem als geheel, bijvoorbeeld de netwerkwerking. Als het systeem geen tijd had om het volgende ontvangen pakket te verwerken, zal dit leiden tot een time-out aan de verzendende kant en opnieuw verzenden (afhankelijk van het protocol natuurlijk). Tegelijkertijd gaan er geen data verloren, maar nemen de netwerkprestaties af. Het belangrijkste verschil tussen harde en zachte real-time systemen kan als volgt worden uitgedrukt: een hard real-time systeem zal nooit te laat reageren op een gebeurtenis, een soft real-time systeem mag niet te laat reageren op een gebeurtenis.

Kernel van het besturingssysteem

De kernel is het centrale deel van het besturingssysteem (OS), dat toepassingen gecoördineerde toegang biedt tot computerbronnen, geheugen, externe hardware, externe invoer- en uitvoerapparaten, en de opdrachten van de toepassingstaal vertaalt in de taal van binaire codes die de computer begrijpt Als een fundamenteel element van het besturingssysteem vertegenwoordigt de kernel het laagste abstractieniveau voor toepassingen om toegang te krijgen tot de systeembronnen die ze nodig hebben om te draaien. In de regel biedt de kernel dergelijke toegang tot de uitvoerbare processen van de corresponderende applicaties door het gebruik van communicatiemechanismen tussen processen en applicatie-aanroepen naar OS-systeemaanroepen.

Monolithische kern

De monolithische kernel biedt een rijke set hardware-abstracties. Alle delen van de monolithische kernel werken in dezelfde adresruimte. Dit is een schema van een besturingssysteem waarin alle componenten van de kernel samenstellende delen van één programma zijn, gemeenschappelijke datastructuren gebruiken en met elkaar interageren door rechtstreeks procedures aan te roepen. Een monolithische kernel is de oudste manier om besturingssystemen te organiseren. De meeste UNIX-systemen zijn voorbeelden van systemen met een monolithische kernel.

Waardigheid: Snelheid van werken, vereenvoudigde ontwikkeling van modules.

nadelen: Aangezien de hele kernel in dezelfde adresruimte werkt, kan een storing in een van de componenten de prestaties van het hele systeem verstoren.

Sommige oudere monolithische kernels, vooral UNIX/Linux-systemen, moesten opnieuw worden gecompileerd wanneer de hardware veranderde. De meeste moderne kernels laten toe om tijdens het draaien modules te laden die een deel van de kernelfuncties uitvoeren. In dit geval zijn de componenten van het besturingssysteem geen onafhankelijke modules, maar samenstellende delen van één groot programma dat een monolithische kernel wordt genoemd, wat een reeks procedures is, die elk elk kunnen aanroepen. Alle procedures werken in de bevoorrechte modus.

Microkernel

De microkernel biedt alleen basisfuncties voor procesbesturing en een minimale set abstracties voor het werken met hardware. Het meeste werk wordt gedaan via speciale aangepaste processen die services worden genoemd. Het doorslaggevende criterium voor "microkernel" is de plaatsing van alle of bijna alle drivers en modules in serviceprocessen.

Waardigheid: Bestand tegen hardwarestoringen, fouten in systeemcomponenten. Het belangrijkste voordeel van de microkernel-architectuur is de hoge mate van modulariteit van de kernel van het besturingssysteem. Dit maakt het veel gemakkelijker om er nieuwe componenten aan toe te voegen. In een microkernel-besturingssysteem is het mogelijk om, zonder de werking ervan te onderbreken, nieuwe stuurprogramma's, bestandssystemen, enz. systeem. De kernelcomponenten van het besturingssysteem verschillen niet fundamenteel van gebruikersprogramma's, dus u kunt conventionele tools gebruiken om ze te debuggen. Microkernel-architectuur verbetert de systeembetrouwbaarheid omdat een bug op het niet-geprivilegieerde programmaniveau minder gevaarlijk is dan een crash op het niveau van de kernelmodus.

nadelen: Het overbrengen van gegevens tussen processen vereist overhead.

Runtime-omgeving

Vereisten voor de uitvoeringsomgeving van realtime systemen zijn als volgt:

• klein systeemgeheugen - voor de mogelijkheid van inbedding;
• het systeem moet volledig geheugenresident zijn om swapping of paging te voorkomen;
• het systeem moet multitasking zijn - om het meest efficiënte gebruik van alle systeembronnen te garanderen;
• kernel met prioriteit voor service-interrupts. Interrupt-prioriteit betekent dat een kant-en-klaar proces met een bepaalde prioriteit noodzakelijkerwijs voorrang krijgt in de wachtrij boven een proces met een lagere prioriteit, dit snel vervangt en voor uitvoering gaat. De kernel voltooit alle servicewerkzaamheden zodra de taak met de hoogste prioriteit arriveert. Dit zorgt voor de voorspelbaarheid van het systeem;
• Prioriteitsdispatcher - Hiermee kan de applicatieontwikkelaar elke opstartmodule een prioriteit toewijzen die buiten de controle van het systeem ligt. Prioritering wordt gebruikt om de volgorde te bepalen waarin programma's gereed voor uitvoering worden uitgevoerd. Een alternatief voor dit type planning is carrousel scheduling, waarbij elk kant-en-klaar programma een gelijke kans heeft om te starten. Met deze methode is er geen controle over welk programma wanneer wordt uitgevoerd. Dit is onaanvaardbaar in een realtime omgeving. Planning met prioriteit en een kernel met interruptprioriteit geven de applicatieontwikkelaar volledige controle over het systeem. Als zich een gebeurtenis met de hoogste prioriteit voordoet, stopt het systeem met het verwerken van de taak met de laagste prioriteit en reageert het op het nieuw ontvangen verzoek.

De combinatie van bovenstaande eigenschappen zorgt voor een krachtige en efficiënte realtime uitvoeringsomgeving.

Naast de eigenschappen van de runtime-omgeving, moet ook rekening worden gehouden met de service die wordt geboden door de realtime OS-kernel. De kern van elke realtime runtime is de kernel of dispatcher. De kernel beheert de hardware van de doelcomputer: de centrale verwerkingseenheid, het geheugen en I/O-apparaten; regelt de werking van alle andere systemen en software van toegepaste aard. In een realtime systeem neemt een dispatcher ruimte in tussen de hardware van de doelcomputer en de toepassingssoftware. Het biedt een speciale service die nodig is om realtime-applicaties uit te voeren. Een service die door de kernel wordt geleverd, geeft applicatieprogramma's toegang tot systeembronnen zoals geheugen of invoer-/uitvoerapparaten.

De kernel kan verschillende soorten diensten leveren:

• Uitwisseling van taken. Het is vaak nodig om de overdracht van gegevens tussen programma's binnen hetzelfde systeem te waarborgen.Bovendien wordt het in veel toepassingen noodzakelijk om via een netwerk met andere systemen te communiceren. Interne communicatie kan via een berichtensysteem. Externe communicatie kan worden georganiseerd via een datagram (de beste leveringsmethode) of via communicatielijnen (gegarandeerde levering). De keuze voor deze of gene methode hangt af van het communicatieprotocol.
• Gegevens scheiding. In realtime toepassingen is het verzamelen van gegevens het meest tijdrovend. Gegevens zijn vaak nodig om andere programma's te laten werken of het systeem moet enkele van zijn functies uitvoeren. Veel systemen bieden toegang tot gedeelde geheugengedeelten. Datawachtrijen zijn wijdverbreid. Er zijn veel soorten wachtrijen, elk met zijn eigen voordelen.
• Verwerken van verzoeken van externe apparaten. Elke applicatie is in realtime verbonden met een specifiek type extern apparaat. De kernel moet I / O-services bieden waarmee applicaties kunnen lezen en schrijven naar deze apparaten. Het is gebruikelijk dat real-time toepassingen een toepassingsspecifiek extern apparaat hebben. De kernel zou een service moeten bieden die het werken met apparaatstuurprogramma's gemakkelijker maakt. Bied bijvoorbeeld de mogelijkheid om te schrijven in talen op hoog niveau, zoals C of Pascal.
• Omgaan met bijzondere situaties. Een uitzondering is een gebeurtenis die optreedt tijdens de uitvoering van het programma. Het kan synchroon zijn als het voorkomen ervan voorspelbaar is, zoals delen door nul. Of het kan asynchroon zijn als het onvoorspelbaar is, zoals een spanningsval. Door de mogelijkheid te bieden om dit soort gebeurtenissen af ​​te handelen, kunnen realtime toepassingen snel en voorspelbaar reageren op interne en externe gebeurtenissen. Er zijn twee methoden voor het afhandelen van uitzonderingen: statuswaarden gebruiken om foutcondities te detecteren en een uitzonderingshandler gebruiken om foutcondities te onderbreken en te corrigeren.

Overzicht van RTOS-architecturen

Tijdens zijn geschiedenis heeft de architectuur van besturingssystemen een aanzienlijke ontwikkeling doorgemaakt. Een van de eerste bouwprincipes, monolithisch OS (Figuur 1), was om het OS weer te geven als een set modules die op verschillende manieren met elkaar interageren binnen de systeemkernel en applicatieprogramma's voorzien van invoerinterfaces voor toegang tot hardware.

gelaagd besturingssysteem (Figuur 2) Een voorbeeld van zo'n besturingssysteem is het bekende MS-DOS-systeem. In systemen van deze klasse konden applicatietoepassingen niet alleen toegang krijgen tot hardware via de systeemkernel of zijn residente services, maar ook rechtstreeks. RTOS is jarenlang op dit principe gebouwd. Vergeleken met monolithische besturingssystemen biedt deze architectuur een veel grotere mate van voorspelbaarheid van systeemreacties en stelt applicatietoepassingen ook in staat snel toegang te krijgen tot hardware. Nadeel

dergelijke systemen zijn het gebrek aan multitasking erin. In deze architectuur werd het probleem van het verwerken van asynchrone gebeurtenissen teruggebracht tot het bufferen van berichten en het vervolgens opeenvolgend pollen van de buffers en verwerking. Tegelijkertijd werd de naleving van de kritische servicevoorwaarden verzekerd door de hoge snelheid van het rekencomplex in vergelijking met de snelheid van externe processen.

Afbeelding 2. Gelaagde OS-architectuur

Een van de meest effectieve architecturen voor het bouwen van realtime besturingssystemen is de client-server-architectuur. Het algemene schema van het besturingssysteem dat op deze technologie werkt, wordt getoond in figuur 3. Het belangrijkste principe van deze architectuur is om OS-services in de vorm van servers naar het gebruikersniveau te brengen, en de microkernel vervult de functies van een berichtverzender tussen clientgebruiker programma's en servers - systeemdiensten. Deze architectuur biedt veel voordelen op het gebied van vereisten voor RTOS en embedded systemen. Deze voordelen omvatten:

1. De betrouwbaarheid van het besturingssysteem neemt toe, aangezien elke service is in feite een op zichzelf staande applicatie en het is gemakkelijker om fouten te debuggen en op te sporen.

2. Zo'n systeem schaalt beter, omdat onnodige services uit het systeem kunnen worden uitgesloten zonder dat dit ten koste gaat van de prestaties.

3. Verhoogt de fouttolerantie van het systeem, omdat: Een bevroren service kan opnieuw worden gestart zonder

herstart het systeem.

Afbeelding 3. Een besturingssysteem bouwen met een client-server-architectuur

Helaas worden tegenwoordig niet veel besturingssystemen op client-serverbasis geïmplementeerd. Tot de bekende RTOS-implementerende microkernel-architectuur behoren OS9 en QNX.

Lijst met gebruikte literatuur:

1) http://ru.wikipedia.org/wiki/Operation_system_real_time

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/