Att beräkna CPU:s burst -tid, vilket är den tid en process behöver för att kontinuerligt använda CPU innan den blockeras eller avslutas, är en avgörande aspekt av processplanering. Det är svårt att veta den * exakta * Burst -tiden i förväg, så algoritmer förlitar sig ofta på
uppskattningar Baserat på tidigare beteende. Här är en uppdelning av hur CPU Burst Times beräknas och uppskattas:
1. Det ideala (och opraktiska) scenariot:att känna till framtiden
* I en perfekt värld skulle du veta den exakta CPU -sprängtiden varje process kommer att behöva * innan * den körs. Detta skulle möjliggöra optimal schemaläggning (t.ex. kortaste jobb först).
* verklighet: Att veta framtiden är omöjligt! Processer kan vara databeroende, inputberoende och påverkas av externa händelser, vilket gör att deras CPU-behov behöver mycket oförutsägbara.
2. Det praktiska tillvägagångssättet:Uppskattning med exponentiell medelvärde
Eftersom vi inte kan veta den exakta burst -tiden använder operativsystem förutsägelsealgoritmer för att uppskatta det. Den vanligaste och effektiva tekniken är exponentiell medelvärde (även känd som åldrande).
* Formel:
`τ_ (n + 1) =α * t_n + (1 - a) * τ_n`
Där:
* `τ_ (n+1)`:Den förutsagda sprängtiden för * nästa * CPU -brast.
* `t_n`:den * faktiska * uppmätta burst -tiden för * senaste * CPU -skuret.
* `τ_n`:* Föregående * förutspådde Burst -tiden. Detta är den uppskattning vi gjorde före den sista sprängningen.
* `α`: utjämningsfaktorn (0 ≤ α ≤ 1). Detta bestämmer vikten som ges till den senaste burst kontra den tidigare förutsägelsen.
* Förklaring:
* Formeln beräknar ett viktat genomsnitt av den tidigare förutsägelsen (`τ_n`) och den senaste faktiska burst -tiden (` t_n`).
* `α` kontrollerar hur snabbt förutsägelsen anpassar sig till förändringar i processens beteende.
* hög α (nära 1): Ger mer vikt till den senaste tidens spräng. Förutsägelsen svarar snabbt på plötsliga förändringar i CPU -krav. Lämplig för processer med korta, variabla skurar.
* låg a (nära 0): Ger mer vikt till tidigare historia. Förutsägelsen är mer stabil och mindre påverkad av tillfälliga fluktuationer. Lämplig för processer med relativt konsekventa CPU -krav.
* När en ny process anländer är den första uppskattningen av Burst Time (`τ_0`) vanligtvis inställd på ett litet, standardvärde (t.ex. 0 eller den genomsnittliga skurtiden för andra processer).
* Exempel:
Låt oss säga:
* `α =0,5`
* `τ_n =10` ms (tidigare förutsägelse)
* `T_N =20` MS (Faktisk Burst -tid just slutförd)
Sedan:
`τ_ (n + 1) =0,5 * 20 + (1 - 0,5) * 10 =10 + 5 =15 'ms
Den förutsagda skurtiden för nästa burst är 15 ms.
3. Hur det fungerar i praktiken (förenklad)
1. Initialisering: När en process startar ställer du in en första uppskattning (`τ_0`).
2. exekvering: Processen körs, och vi mäter dess faktiska CPU -burst -tid (`t_n`).
3. Uppskattning: När Burst har slutförts använder du den exponentiella genomsnittliga formeln för att beräkna den nya förutsagda burst -tiden (`τ_ (n+1)`).
4. Upprepa: Processen fortsätter att gå, och vi upprepar steg 2 och 3 efter varje brast. Förutsägelsen uppdateras kontinuerligt.
4. Överväganden och utmaningar
* Att välja α: Att välja rätt `α` -värde är kritiskt. Det finns inget enda "bästa" värde. Det beror på egenskaperna hos de processer som körs på systemet. Vissa operativsystem kan dynamiskt justera `α 'baserat på observerat processbeteende.
* noggrannhet: Exponentiell medelvärde är en *uppskattning *, inte en perfekt prediktor. Förutsägelsens noggrannhet beror på processens beteende och valet av `α '.
* Kontextbyte över huvudet: Kostnaden för att mäta burst -tider och uppdatera uppskattningar måste beaktas, särskilt om sammanhangsomkopplare är ofta.
* Andra förutsägelsetekniker: Även om exponentiell medelvärde är den vanligaste, finns det andra tekniker, till exempel att använda mer komplexa historiska medelvärden eller maskininlärningsmodeller. Dessa används emellertid mindre ofta på grund av den extra komplexiteten och potentiella omkostnaden.
Sammanfattningsvis handlar det om att beräkna CPU -burst -tiden * att uppskatta * det med tidigare beteende. Exponentiell medelvärde är en enkel men ändå effektiv metod som gör det möjligt för operativsystemet att anpassa sig till processens förändrade CPU -krav, vilket möjliggör bättre schemaläggningsbeslut.
