.\" -*- coding: UTF-8 -*- .\" Copyright 1996-1999, Tom Bjorkholm .\" Copyright 1996-1999, Markus Kuhn .\" Copyright 1996-1999, David A. Wheeler .\" Copyright 2008-2014, Michael Kerrisk .\" Copyright 2014, Peter Zijlstra .\" Copyright 2014, Juri Lelli .\" Copyright, the authors of the Linux man-pages project .\" .\" SPDX-License-Identifier: GPL-2.0-or-later .\" .\"******************************************************************* .\" .\" This file was generated with po4a. Translate the source file. .\" .\"******************************************************************* .TH sched 7 "8 lutego 2026 r." "Linux man\-pages 6.17" .SH NAZWA sched \- przegląd szeregowania zadań .SH OPIS .\" Od Linuksa 2.6.23, domyślnym planistą jest CFS, \[Bq]Completely Fair Scheduler\[rq] (zupełnie sprawiedliwy dyspozytor). Planista CFS zastąpił wcześniejszego dyspozytora \[Bq]O(1)\[rq]. .SS "Podsumowanie API" Linux udostępnia poniższe wywołania systemowe, służące do kontrolowania zachowania planisty procesora, algorytmu oraz priorytetów procesów (lub precyzyjniej: wątków). .TP \fBnice\fP(2) Ustawia nową wartość nice wątku wywołującego i zwraca nową wartość nice. .TP \fBgetpriority\fP(2) Zwraca wartość nice wątku, grupy procesów lub zbioru wątków podanego użytkownika. .TP \fBsetpriority\fP(2) Ustawia wartość wątku, grupy procesów lub zbioru wątków podanego użytkownika. .TP \fBsched_setscheduler\fP(2) Ustawia algorytm i parametry szeregowania podanego wątku. .TP \fBsched_getscheduler\fP(2) Zwraca algorytm szeregowania podanego wątku. .TP \fBsched_setparam\fP(2) Ustawia parametry szeregowania podanego wątku. .TP \fBsched_getparam\fP(2) Pobiera parametry szeregowania podanego wątku. .TP \fBsched_get_priority_max\fP(2) Zwraca maksymalny dostępny priorytet w danym algorytmie szeregowania. .TP \fBsched_get_priority_min\fP(2) Zwraca minimalny dostępny priorytet w danym algorytmie szeregowania. .TP \fBsched_rr_get_interval\fP(2) Pobiera kwant używany wobec wątków szeregowanych przez algorytm karuzelowy (\[Bq]round\-robin\[rq]). .TP \fBsched_yield\fP(2) Powoduje zwolnienie procesora przez wywołującego, dzięki czemu może być wykonany jakiś inny wątek. .TP \fBsched_setaffinity\fP(2) (typowo linuksowe) Ustawia koligację procesora podanego wątku. .TP \fBsched_getaffinity\fP(2) (typowo linuksowe) Pobiera koligację procesora podanego wątku. .TP \fBsched_setattr\fP(2) Ustawia algorytm i parametry szeregowania podanego wątku. To (typowo linuksowe) wywołanie systemowe zapewnia nadzbiór funkcjonalności \fBsched_setscheduler\fP(2) oraz \fBsched_setparam\fP(2). .TP \fBsched_getattr\fP(2) .\" Pobiera algorytm i parametry szeregowania podanego wątku. To (typowo linuksowe) wywołanie systemowe zapewnia nadzbiór funkcjonalności \fBsched_getscheduler\fP(2) oraz \fBsched_getparam\fP(2). .SS "Algorytmy szeregowania" Planista (dyspozytor) to część jądra decydująca o tym, który gotowy do działania wątek zostanie wykonany przez procesor jako następny. Każdy wątek ma przypisany algorytm szeregowania zadań oraz \fIstatyczny\fP priorytet szeregowania, \fIsched_priority\fP. Dyspozytor podejmuje swe decyzje w oparciu o wiedzę o algorytmie szeregowania oraz statycznych priorytetach wszystkich wątków w systemie. .P W przypadku wątków korzystających z jednego ze zwykłych algorytmów szeregowania (\fBSCHED_OTHER\fP, \fBSCHED_IDLE\fP, \fBSCHED_BATCH\fP), \fIsched_priority\fP nie jest stosowane przy podejmowaniu decyzji o szeregowaniu (musi być podane jako 0). .P Procesy korzystające z jednego z algorytmów szeregowania czasu rzeczywistego (\fBSCHED_FIFO\fP, \fBSCHED_RR\fP) mają wartość \fIsched_priority\fP z przedziału od 1 (niski) do 99 (wysoki). Jak wskazują wartości, wątki czasu rzeczywistego mają zawsze wyższy priorytet od zwykłych wątków. Proszę zauważyć, że POSIX.1 wymaga obsługi przez implementację co najmniej 32 oddzielnych poziomów priorytetów w przypadku algorytmów szeregowania czasu rzeczywistego i niektóre systemy obsługują tylko to minimum. Przenośne programy powinny stosować \fBsched_get_priority_min\fP(2) i \fBsched_get_priority_max\fP(2), aby poznać przedział priorytetów obsługiwanych dla danego algorytmu. .P Idea jest taka, że dyspozytor zarządza listą działających wątków dla każdej możliwej wartości \fIsched_priority\fP. Aby określić następny uruchomiony wątek, planista szuka niepustej listy o najwyższym statycznym priorytecie i wybiera wątek na jej początku. .P Algorytm szeregowania wątku określa miejsce, w którym zostanie on umieszczony na liście wątków o takim samym statycznym priorytecie oraz sposób przemieszczenia się wewnątrz tej listy. .P Wszelkie szeregowanie następuje z wywłaszczaniem: jeśli pojawi się wątek o wyższym priorytecie gotowy do uruchomienia, aktualnie uruchomiony wątek zostanie wywłaszczony i powróci na listę oczekujących swego statycznego poziomu priorytetu. Algorytm szeregowania określa kolejność jedynie na liście działających wątków o takim samym statycznym priorytecie. .SS "SCHED_FIFO: Szeregowanie typu pierwszy na wejściu, pierwszy na wyjściu" Algorytm \fBSCHED_FIFO\fP (z ang. first in\-first out) można stosować tylko ze statycznymi priorytetami wyższymi niż 0, co oznacza, że gdy wątek \fBSCHED_FIFO\fP stanie się gotowy do uruchomienia, zawsze natychmiast wywłaszczy każdy działający wątek \fBSCHED_OTHER\fP, \fBSCHED_BATCH\fP lub \fBSCHED_IDLE\fP. \fBSCHED_FIFO jest algorytmem prostego planowania\fP bez podziału na wycinki czasowe. Do wątków szeregowanych według algorytmu \fBSCHED_FIFO\fP stosują się następujące reguły: .IP \[bu] 3 Działający wątek \fBSCHED_FIFO\fP wywłaszczony przez inny wątek o wyższym priorytecie pozostanie na czele listy swojego priorytetu i wznowi wykonanie, gdy tylko wszystkie wątki o wyższym priorytecie zostaną ponownie zablokowane. .IP \[bu] Gdy zablokowany wątek \fBSCHED_FIFO\fP stanie się gotowy do uruchomienia, zostanie umieszczony na końcu listy swojego priorytetu. .IP \[bu] Gdy wywołanie do \fBsched_setscheduler\fP(2), \fBsched_setparam\fP(2), \fBsched_setattr\fP(2), \fBpthread_setschedparam\fP(3) lub \fBpthread_setschedprio\fP(3) zmieni priorytet działającego lub gotowego do działania wątku \fBSCHED_FIFO\fP, identyfikowanego przez \fIpid\fP, efekt pozycji wątku na liście zależy od kierunku zmiany priorytetu wątku: .RS .IP (a) 5 Jeśli podnosi się priorytet wątku, jest on umieszczany na końcu listy jego nowego priorytetu. Może zatem wywłaszczyć aktualnie działający wątek o tym samym priorytecie. .IP (b) Jeśli priorytet wątku nie ulega zmianie, jego pozycja na liście nie ulega zmianie. .IP (c) Jeśli obniża się priorytet wątku, jest on umieszczany na czele listy jego nowego priorytetu. .RE .IP .\" In Linux 2.2.x and Linux 2.4.x, the thread is placed at the front of the queue .\" In Linux 2.0.x, the Right Thing happened: the thread went to the back -- MTK Zgodnie z POSIX.1\-2008, zmiany priorytetu (lub algorytmu szeregowania) wątku, dokonane mechanizmem innym niż \fBpthread_setschedprio\fP(3), powinny spowodować umieszczenie wątku na końcu listy jego priorytetu. .IP \[bu] Wątek wywołujący \fBsched_yield\fP(2) zostanie umieszczony na końcu listy. .P Nie występują inne zdarzenia mogące przesunąć wątek szeregowany według algorytmu \fBSCHED_FIFO\fP na liście oczekujących wątków gotowych do działania o tym samym priorytecie statycznym. .P Wątek \fBSCHED_FIFO\fP działa do momentu zablokowania przez żądanie wejścia/wyjścia, wywłaszczenia przez wątek o wyższym priorytecie lub wywołania przez niego \fBsched_yield\fP(2). .SS "SCHED_RR: Szeregowanie rotacyjne (karuzelowe)" .\" On Linux 2.4, the length of the RR interval is influenced .\" by the process nice value -- MTK .\" Algorytm \fBSCHED_RR\fP (z ang. round\-robin) jest prostym rozszerzeniem \fBSCHED_FIFO\fP. Wszystko, co opisano powyżej wobec \fBSCHED_FIFO\fP, stosuje się również wobec \fBSCHED_RR\fP z tym wyjątkiem, że każdy wątek może działać jedynie przez maksymalny kwant czasu. Jeśli wątek \fBSCHED_RR\fP działał przez czas równy lub dłuższy kwantowi czasu, zostanie umieszczony na końcu listy dla jego priorytetu. Wątek \fBSCHED_RR\fP wywłaszczony przez wątek o wyższym priorytecie, który następnie wznowił działanie jako wątek działający, ukończy niewygasły fragment swojego kwantu czasu szeregowania rotacyjnego. Długość kwantu czasu można pozyskać za pomocą \fBsched_rr_get_interval\fP(2). .SS "SCHED_DEADLINE: Szeregowanie sporadyczne z budżetem czasu" Od Linuksa 3.14, Linux udostępnia szeregowanie sporadyczne z budżetem czasu (\fBSCHED_DEADLINE\fP). Ten algorytm zaimplementowano obecnie za pomocą GEDF (Global Earliest Deadline First) w połączeniu z CBS (Constant Bandwidth Server). Aby ustawić i pobrać ten algorytm wraz z powiązanymi atrybutami, konieczne jest użycie typowo linuksowych wywołań systemowych \fBsched_setattr\fP(2) i \fBsched_getattr\fP(2). .P Zadaniem sporadycznym jest takie, które ma sekwencje zadań, z których każde jest aktywowane co najwyżej raz na okres. Każde zadanie ma też \fIlimit względny\fP, przed którym powinno ukończyć wykonanie oraz \fIczas obliczeniowy\fP, który jest czasem procesora potrzebnym na wykonanie zadania. Moment, w którym zadanie wybudza się, ze względu na nową pracę do wykonania, nazywa się \fImomentem nadejścia\fP (również momentem żądania lub momentem zwolnienia). \fIMoment uruchomienia\fP to czas, w którym zadanie rozpoczyna swe wykonywanie. \fILimit absolutny\fP powstaje zatem przez dodanie limitu względnego do czasu nadejścia. .P Poniższy diagram ukazuje powyższe pojęcia: .P .in +4n .EX nadejście/wybudzenie limit absolutny | moment uruchomienia | | | | v v v \-\-\-\-\-x\-\-\-\-\-\-\-\-xooooooooooooooooo\-\-\-\-\-\-\-\-x\-\-\-\-\-\-\-\-x\-\-\- |<\- czas obl.\& \-\->| |<\-\-\-\-\-\-\-\- limit względny \-\-\-\-\-\-\-\->| |<\-\-\-\-\-\-\-\-\-\-\-\-\-\- okres \-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\->| .EE .in .P Przy ustawianiu algorytmu \fBSCHED_DEADLINE\fP wobec wątku za pomocą \fBsched_setattr\fP(2), można podać trzy parametry: \fICzas Działania\fP (\fIRuntime\fP), \fILimit\fP (\fIDeadline\fP) oraz \fIOkres\fP (\fIPeriod\fP). Parametry te niekoniecznie odpowiadają wcześniej wymienionym pojęciom: praktyką jest zwykle ustawienie Czasu Działania na wartość większą niż przeciętny czas obliczeniowy (lub czas wykonania w najgorszym wariancie, w przypadku trudnych zadań czasu rzeczywistego), Limit na limit względny a Okres na okres zadania. Zatem w szeregowaniu \fBSCHED_DEADLINE\fP mamy: .P .in +4n .EX nadejście/wybudzenie limit absolutny | moment uruchomienia | | | | v v v \-\-\-\-\-x\-\-\-\-\-\-\-\-xooooooooooooooooo\-\-\-\-\-\-\-\-x\-\-\-\-\-\-\-\-x\-\-\- |<\- Czas Działania \->| |<\-\-\-\-\-\-\-\-\-\-\-\-\- Limit \-\-\-\-\-\-\-\-\-\-\-\->| |<\-\-\-\-\-\-\-\-\-\-\-\-\-\- Okres \-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\->| .EE .in .P .\" FIXME It looks as though specifying sched_period as 0 means .\" "make sched_period the same as sched_deadline". .\" This needs to be documented. Trzy parametry niniejszego szeregowania odpowiadają polom \fIsched_runtime\fP, \fIsched_deadline\fP oraz \fIsched_period\fP struktury \fIsched_attr\fP; zob. \fBsched_setattr\fP(2). Pola te wyrażają wartości w nanosekundach. Jeśli poda się \fIsched_period\fP jako 0, przyjmowana jest wartość taka sama jak w \fIsched_deadline\fP. .P Jądro wymaga aby: .P .in +4n .EX sched_runtime <= sched_deadline <= sched_period .EE .in .P .\" See __checkparam_dl in kernel/sched/core.c Dodatkowo, w bieżącej implementacji, wszystkie wartości parametrów muszą wynosić przynajmniej 1024 (tj. odrobinę ponad jedną mikrosekundę, stanowiącą rozdzielczość implementacji) i mniej niż 2\[ha]63. Jeśli któryś z tych warunków nie będzie spełniony, \fBsched_setattr\fP(2) zawiedzie z błędem \fBEINVAL\fP. .P CBS gwarantuje brak interferencji pomiędzy zadaniami, poprzez dławienie wątków próbujących przekroczyć ich określony Czas Działania. .P Aby zagwarantować szeregowanie z budżetem czasu, jądro musi zapobiegać sytuacjom, gdy uszeregowanie zbioru wątków \fBSCHED_DEADLINE\fP jest nierealistyczne w podanych ograniczeniach czasowych. Jądro dokonuje zatem testu przyjęcia przy ustawianiu lub zmienianiu algorytmu i atrybutów \fBSCHED_DEADLINE\fP. Test przyjęcia polega na obliczeniu, czy zmiana jest realistyczna: jeśli nie jest, \fBsched_setattr\fP(2) zawiedzie z błędem \fBEBUSY\fP. .P Na przykład, jest wymagane (lecz niekoniecznie wystarczające), aby całkowite użycie było mniejsze lub równe całkowitej liczbie dostępnych procesorów, ponieważ każdy wątek może działać maksymalnie przez Czas Działania na Okres, czyli jego użycie wynosi Czas Działania dzielony przez jego Okres. .P Aby wypełnić gwarancje uczynione przy przyjęciu wątku przez algorytm \fBSCHED_DEADLINE\fP, wątki \fBSCHED_DEADLINE\fP są wątkami o najwyższym (kontrolowanym przez użytkownika) priorytecie w systemie; jeśli działa jakiś wątek \fBSCHED_DEADLINE\fP, wywłaszczy on wszystkie wątki szeregowane według innych algorytmów. .P Wywołanie \fBfork\fP(2) przez wątek szeregowany według algorytmu \fBSCHED_DEADLINE\fP zawiedzie z błędem \fBEAGAIN\fP, chyba że wątek ma ustawiony swój znacznik reset\-on\-fork (zob. niżej). .P .\" .\" FIXME Calling sched_getparam() on a SCHED_DEADLINE thread .\" fails with EINVAL, but sched_getscheduler() succeeds. .\" Is that intended? (Why?) .\" Wątek \fBSCHED_DEADLINE\fP po wywołaniu \fBsched_yield\fP(2) zwolni bieżącą pracę i zaczeka na rozpoczęcie nowego okresu. .SS "SCHED_OTHER: Domyślny sposób szeregowania zadań w Linuksie" Algorytm \fBSCHED_OTHER\fP można stosować tylko ze statycznym priorytetem 0 (tj. wątki szeregowane przez algorytmy czasu rzeczywistego są zawsze priorytetowe wobec procesów \fBSCHED_OTHER\fP). \fBSCHED_OTHER\fP jest standardowym algorytmem szeregowania w Linuksie, przeznaczonym do wszystkich wątków niewymagających specjalnych mechanizmów czasu rzeczywistego. .P Wątek do uruchomienia jest wybierany z listy o statycznym priorytecie 0, w oparciu o priorytet \fIdynamiczny\fP, określany jedynie wewnątrz tej listy. Priorytet dynamiczny bazuje na wartości nice (zob. niżej) i jest zwiększany przy każdym kwancie czasu, w którym wątek jest gotowy do uruchomienia, ale odmówił mu tego dyspozytor (tzw. postarzanie wątku). W ten sposób uzyskuje się sprawiedliwy postęp dla wszystkich wątków \fBSCHED_OTHER\fP. .P .\" W kodzie źródłowym jądra Linux, algorytm \fBSCHED_OTHER\fP nazywa się tak naprawdę \fBSCHED_NORMAL\fP. .SS "Wartość nice" Wartość nice jest atrybutem, który można wpłynąć na dyspozytora, aby faworyzował (lub przeciwnie) proces w decyzjach szeregowania zadań. Wpływa na szeregowanie procesów \fBSCHED_OTHER\fP i \fBSCHED_BATCH\fP (zob. niżej). Wartość nice można modyfikować za pomocą \fBnice\fP(2), \fBsetpriority\fP(2) lub \fBsched_setattr\fP(2). .P Zgodnie z POSIX.1, wartość nice jest atrybutem przynależnym procesowi; tj. wątki procesu powinny dzielić wartość nice. Jednak w Linuksie wartość nice jest atrybutem przynależnym wątkowi: różne wątki tego samego procesu mogą mieć różne wartości nice. .P .\" Linux before 1.3.36 had \-infinity..15. .\" Since Linux 1.3.43, Linux has the range \-20..19. Przedział wartości nice różni się między systemami UNIX. We współczesnym Linuksie przedział wynosi od \-20 (wysoki priorytet) do +19 (niski priorytet). W niektórych innych systemach wynosi on \-20..20. Bardzo wczesne jądra Linux (przed Linuksem 2.0) korzystały z przedziału \-nieskończoność..15. .P Poziom wpływu wartości nice na relatywne szeregowanie procesów \fBSCHED_OTHER\fP również różni się między systemami UNIX oraz pomiędzy wersjami jądra Linux. .P Wraz z wprowadzeniem dyspozytora CFS w Linuksie 2.6.23, Linux przyjął algorytm przewidujący znacznie większy wpływ relatywnych różnic wartości nice. W bieżącej implementacji, różnica każdej jedności w wartości nice pomiędzy dwoma procesami stanowi mnożnik 1,25, o jaki planista faworyzuje proces o wyższym priorytecie. Powoduje to zapewnienie rzeczywiście niewielkiego czasu procesora procesom o bardzo niskim priorytecie (wartość nice +19), gdy w systemie występują istotniejsze zadania oraz udostępnia większość procesora przy wysokim priorytecie (wartość nice \-20) aplikacjom, które tego wymagają (np. niektóre programy związane z dźwiękiem). .P W Linuksie, za pomocą limitu zasobów \fBRLIMIT_NICE\fP, można zdefiniować limit wartość nice, jaki może uzyskać nieuprzywilejowany proces; więcej szczegółów w podręczniku \fBsetrlimit\fP(2). .P .\" Więcej szczegółów na temat wartości nice opisano poniżej, w podrozdziałach o funkcji autogrupowania i szeregowania grup. .SS "SCHED_BATCH: Szeregowanie procesów wsadowych" (Od Linuksa 2.6.16). Algorytm \fBSCHED_BATCH\fP można stosować wyłącznie ze statycznym priorytetem 0. Algorytm podobny do \fBSCHED_OTHER\fP w tym, że szereguje wątki zgodnie z ich priorytetem dynamicznym (bazującym na wartości nice). Różnica jest taka, że tutaj dyspozytor zawsze zakłada, że wątek jest obciążający dla procesora. W konsekwencji, planista zastosuje niewielką karę przy wybudzeniu, co powoduje umiarkowanie rzadsze przydzielanie mu zasobów. .P .\" The following paragraph is drawn largely from the text that .\" accompanied Ingo Molnar's patch for the implementation of .\" SCHED_BATCH. .\" commit b0a9499c3dd50d333e2aedb7e894873c58da3785 .\" Algorytm przydatny w przypadku obciążeń nieinteraktywnych, które jednak nie chcą zmniejszać swojego priorytetu poprzez wartość nice oraz w przypadku obciążeń wymagających deterministycznego algorytmu szeregowania, bez dodatkowego wywłaszczania wywoływanego przez interaktywność (pomiędzy ich zadaniami). .SS "SCHED_IDLE: Szeregowanie zadań o bardzo niskim priorytecie" (Od Linuksa 2.6.23). Algorytm \fBSCHED_IDLE\fP można stosować tylko ze statycznym priorytetem 0; wartość nice procesu nie ma na niego wpływu. .P .\" Przeznaczony do uruchamiania zadań o ekstremalnie niskim priorytecie (niższym nawet niż wartość nice +19 w algorytmach \fBSCHED_OTHER\fP lub \fBSCHED_BATCH\fP). .SS "Resetowanie algorytmu szeregowania procesów potomnych" Każdy wątek ma znacznik szeregowania reset\-on\-fork (zresetuj przy rozwidleniu). Gdy jest ustawiony, potomkowie utworzeni przy \fBfork\fP(2) nie dziedziczą uprzywilejowanych algorytmów szeregowania. Znacznik reset\-on\-fork może być ustawiony przez: .IP \[bu] 3 zsumowanie (logiczne OR) znacznika \fBSCHED_RESET_ON_FORK\fP do argumentu \fIpolicy\fP przy wywołaniu \fBsched_setscheduler\fP(2) (od Linuksa 2.6.32); albo .IP \[bu] podanie znacznika \fBSCHED_FLAG_RESET_ON_FORK\fP w \fIattr.sched_flags\fP przy wywołaniu \fBsched_setattr\fP(2). .P Proszę zauważyć, że stałe używane przez oba interfejsy mają różne nazwy. Stan znacznika reset\-on\-fork można analogicznie pobrać za pomocą \fBsched_getscheduler\fP(2) i \fBsched_getattr\fP(2). .P Funkcja reset\-on\-fork jest przeznaczona do aplikacji odtwarzających media i może posłużyć do uniknięcia możliwości ominięcia przez aplikacje limitu zasobu \fBRLIMIT_RTTIME\fP (zob. \fBgetrlimit\fP(2)) przez tworzenie wielu procesów potomnych. .P Precyzyjniej: jeśli ustawiono znacznik reset\-on\-fork, do nowo tworzonych potomków stosują się następujące zasady: .IP \[bu] 3 Jeśli wątek wywołujący ma ustawiony algorytm szeregowania \fBSCHED_FIFO\fP lub \fBSCHED_RR\fP, algorytm jest resetowany na \fBSCHED_OTHER\fP w procesach potomnych. .IP \[bu] Jeśli proces wywołujący ma ujemną wartość nice, wartość nice jest resetowana na zero w procesach potomnych. .P .\" Po włączeniu znacznika reset\-on\-fork, można go zresetować tylko, jeśli wątek ma przywilej \fBCAP_SYS_NICE\fP. Znacznik jest wyłączony w procesach potomnych tworzonych przez \fBfork\fP(2). .SS "Przywileje i limity zasobów" Przed Linuksem 2.6.12, tylko wątki uprzywilejowane (\fBCAP_SYS_NICE\fP) mogą mieć ustawiony niezerowy priorytet statyczny (tj. ustawiony algorytm szeregowania czasu rzeczywistego). Jedyną zmianę, jaką może dokonać nieuprzywilejowany wątek, jest ustawienie algorytmu \fBSCHED_OTHER\fP, a to można zrobić tylko, jeśli efektywny identyfikator użytkownika wywołującego jest równy rzeczywistemu lub efektywnemu identyfikatorowi użytkownika wątku docelowego (tj. wątku określonemu przez \fIpid\fP), którego algorytm jest zmieniany. .P Wątek musi być uprzywilejowany (\fBCAP_SYS_NICE\fP), aby ustawić lub zmodyfikować algorytm \fBSCHED_DEADLINE\fP. .P Od Linuksa 2.6.12, limit zasobów \fBRLIMIT_RTPRIO\fP definiuje górny limit statycznego priorytetu wątku nieuprzywilejowanego w algorytmach \fBSCHED_RR\fP i \fBSCHED_FIFO\fP. Reguły zmiany algorytmów szeregowania i priorytetów są następujące: .IP \[bu] 3 Jeśli nieuprzywilejowany wątek ma niezerowy miękki limit \fBRLIMIT_RTPRIO\fP, to może zmienić swój algorytm szeregowania zadań i priorytet, z takim ograniczeniem, że priorytet nie może być ustawiony na wyższy niż maksymalna z wartości: jego bieżącego priorytetu i jego limitu miękkiego \fBRLIMIT_RTPRIO\fP. .IP \[bu] Jeśli miękki limit \fBRLIMIT_RTPRIO\fP wynosi 0, to jedynymi dozwolonymi zmianami są: obniżenie priorytetu lub przełączenie z algorytmu czasu rzeczywistego na niebędący takowym. .IP \[bu] Wedle tych samych zasad, inny nieuprzywilejowany wątek może również dokonać tych zmian, o ile efektywny identyfikator użytkownika wątku dokonującego zmiany jest taki sam, jak rzeczywisty lub efektywny identyfikator użytkownika wątku docelowego. .IP \[bu] .\" commit c02aa73b1d18e43cfd79c2f193b225e84ca497c8 Specjalne zasady tyczą się algorytmu \fBSCHED_IDLE\fP. Przed Linuksem 2.6.39, nieuprzywilejowany wątek działający według tego algorytmu nie mógł go zmienić, niezależnie od wartości jego limitu zasobów \fBRLIMIT_RTPRIO\fP. Od Linuksa 2.6.39, nieuprzywilejowany wątek może przełączyć się na algorytm \fBSCHED_BATCH\fP lub \fBSCHED_OTHER\fP, o ile jego wartość nice znajduje się w przedziale dozwolonym przez jego limit zasobów \fBRLIMIT_NICE\fP (zob. \fBgetrlimit\fP(2)). .P Wątki uprzywilejowane (\fBCAP_SYS_NICE\fP) ignorują limit \fBRLIMIT_RTPRIO\fP; podobnie jak w starszych jądrach, mogą dokonywać dowolnych zmian dotyczących algorytmu szeregowania zadań i priorytetów. Więcej informacji na temat \fBRLIMIT_RTPRIO\fP znajduje się w podręczniku \fBgetrlimit\fP(2). .SS "Ograniczanie użycia procesora przez procesy czasu rzeczywistego i z budżetem czasu" Nieblokująca, nieskończona pętla w wątku zaszeregowanym według algorytmu \fBSCHED_FIFO\fP, \fBSCHED_RR\fP lub \fBSCHED_DEADLINE\fP potencjalnie może na zawsze zablokować dostęp do procesora wszystkim innym wątkom. Przed Linuksem 2.6.25, jedynym sposobem zapobiegnięcia zamrożenia systemu przez zbiegły proces czasu rzeczywistego było uruchomienie (na konsoli) powłoki zaszeregowanej z wyższym priorytetem statycznym niż testowana aplikacja. Można było w ten sposób awaryjnie zabić testowaną aplikację czasu rzeczywistego, która nie zablokowała lub nie zakończyła się zgodnie z oczekiwaniami. .P Od Linuksa 2.6.25, istnieją inne techniki radzenia sobie ze zbiegłymi procesami czasu rzeczywistego i z budżetem czasu. Jedną z nich jest użycie limitu zasobów \fBRLIMIT_RTTIME\fP do nałożenia ograniczenia na czas procesora, jaki może skonsumować proces czasu rzeczywistego. Więcej szczegółów w podręczniku \fBgetrlimit\fP(2). .P Od Linuksa 2.6.25, Linux zapewnia również dwa pliki \fI/proc\fP, które mogą posłużyć do zarezerwowania określonej ilości czasu procesora dla procesów innych niż czasu rzeczywistego. Zarezerwowanie czasu procesora w ten sposób, pozwala również na przydzielenie pewnej ilości czasu procesora dla (przykładowo) powłoki roota, z której można zabić zbiegły proces. Oba pliki określają wartości czasu w mikrosekundach: .TP \fI/proc/sys/kernel/sched_rt_period_us\fP Plik określa \[Bq]okres szeregowania zadań\[rq] równoważny 100% przepustowości procesora. Wartość w pliku może być z zakresu od 1 do \fBINT_MAX\fP, czyli od 1 mikrosekundy do około 35 minut. Domyślna wartość w pliku wynosi 1\ 000\ 000 (1 sekunda). .TP \fI/proc/sys/kernel/sched_rt_runtime_us\fP Wartość w tym pliku określa, jak dużo tego \[Bq]okresu szeregowania zadań\[rq] w systemie może być przeznaczone na wszystkie procesy czasu rzeczywistego oraz procesy szeregowane z budżetem czasu. Wartość w pliku może być z zakresu od \-1 do \fBINT_MAX\fP\-1. Podanie \-1 uczyni ten czas takim samym jak ten okres; tj. nie odkłada się czasu procesora na procesy inne niż czasu rzeczywistego (takie zachowanie występowało przed Linuksem 2.6.25). Wartość domyślna w pliku to 950\ 000 (0,95 sekundy), co oznacza że 5% czasu procesora jest zarezerwowane na procesy szeregowane wedle algorytmów innych niż czasu rzeczywistego i z budżetem czasu. .SS "Czas odpowiedzi" .\" as described in .\" .BR request_irq (9). Zablokowany wątek o wysokim priorytecie oczekujący na wejście/wyjście ma określony czas odpowiedzi, zanim zostanie ponownie zaszeregowany. Sterownik zapisujący urządzenia może znacznie ograniczyć ten czas odpowiedzi poprzez korzystanie z procedury obsługi przerwań zwanej \[Bq]slow interrupt\[rq]. .SS Różne Procesy potomne dziedziczą algorytm i parametry szeregowania poprzez \fBfork\fP(2). Algorytm i parametry szeregowania są zachowywane poprzez \fBexecve\fP(2). .P .\" W przypadku procesów czasu rzeczywistego, aby uniknąć opóźnień związanych ze stronicowaniem, potrzebne jest zwykle blokowanie pamięci; można go dokonywać za pomocą \fBmlock\fP(2) lub \fBmlockall\fP(2). .SS "Funkcja autogrupowania" .\" commit 5091faa449ee0b7d73bc296a93bca9540fc51d0a Od Linuksa 2.6.38, jądro zapewnia funkcję zwaną autogrupowaniem, która ma na celu poprawienie wydajności interaktywnych środowisk graficznych, podczas wykonywania wieloprocesowych, mocno obciążających procesor prac, takich jak budowanie jądra Linux z wieloma równoległymi procesami budowania (tj. z opcją \fB\-j\fP \fBmake\fP(1)). .P Funkcja działa razem z planistą CFS i wymaga, aby jądro było skonfigurowane z opcją \fBCONFIG_SCHED_AUTOGROUP\fP. W działającym systemie, funkcję można włączyć lub wyłączyć poprzez plik \fI/proc/sys/kernel/sched_autogroup_enabled\fP; wartość 0 wyłącza tę funkcję, a wartość 1 ją włącza. Domyślną wartością w pliku jest 1, chyba że podczas rozruchu jądra ustawiono parametr \fInoautogroup\fP. .P Nowa autogrupa jest tworzona przy tworzeniu nowej sesji za pomocą \fBsetsid\fP(2); dzieje się tak np. przy uruchamianiu nowego okna terminala. Nowy proces tworzony przez \fBfork\fP(2) dziedziczy członkostwo w autogrupie swojego rodzica. Wszystkie procesy w sesji są zatem członkami tej samej autogrupy. Autogrupa jest automatycznie niszczona, gdy zakończy się ostatni proces grupy. .P Gdy autogrupowanie jest włączone, wszyscy członkowie autogrupy są umieszczani w tej samej \[Bq]grupie zadań\[rq] dyspozytora jądra. Gdy jest wyłączone, tworzenie grup odbywa się tak samo, członkostwo w autogrupie jest wciąż widoczne w \fI/proc\fP, lecz autogrupy nie są używane. Planista CFS używa algorytmu wyrównującego rozłożenie cykli procesora pomiędzy grupami zadań. Korzyści, jakie z tego wynikają dla wydajności interaktywnego środowiska graficznego może przybliżyć następujący przykład. .P .\" Mike Galbraith, 25 Nov 2016: .\" I'd say something more wishy-washy here, like cycles are .\" distributed fairly across groups and leave it at that, as your .\" detailed example is incorrect due to SMP fairness (which I don't .\" like much because [very unlikely] worst case scenario .\" renders a box sized group incapable of utilizing more that .\" a single CPU total). For example, if a group of NR_CPUS .\" size competes with a singleton, load balancing will try to give .\" the singleton a full CPU of its very own. If groups intersect for .\" whatever reason on say my quad lappy, distribution is 80/20 in .\" favor of the singleton. Załóżmy, że są dwie autogrupy rywalizujące o ten sam procesor (tj. może być to system jednoprocesorowy albo wykorzystano \fBtaskset\fP(1) do ograniczenia wszystkich procesów do tego samego procesora w wieloprocesorowym systemie SMP). Pierwsza grupa zawiera dziesięć procesów ograniczonych wydajnością procesora, pochodzących od polecenia budującego jądro: \fImake\ \-j10\fP. Druga zawiera jeden proces ograniczony wydajnością procesora: odtwarzacz wideo. Efekt autogrupowania jest taki, że obie grupy otrzymają po połowie cykli procesora. Odtwarzacz wideo otrzyma zatem 50% cykli procesora, zamiast 9%, które najprawdopodobniej odbiły by się negatywnie na ciągłości odtwarzania wideo. Sytuacja w wieloprocesorowym systemie SMP jest bardziej złożona, ale ogólny efekt jest taki sam: dyspozytor rozkłada cykle procesora pomiędzy poszczególne grupy zadaniowe w ten sposób, że autogrupy zawierające dużą liczbę procesów ograniczonych wydajnością procesora nie zmonopolizują cykli procesora kosztem innych zadań systemu. .P Członkostwo procesu w autogrupie (grupie zadań) można sprawdzić w pliku \fI/proc/\fPpid\fI/autogroup\fP: .P .in +4n .EX $\fB cat /proc/1/autogroup\fP /autogroup\-1 nice 0 .EE .in .P .\" FIXME . .\" Because of a bug introduced in Linux 4.7 .\" (commit 2159197d66770ec01f75c93fb11dc66df81fd45b made changes .\" that exposed the fact that autogroup didn't call scale_load()), .\" it happened that *all* values in this range caused a task group .\" to be further disfavored by the scheduler, with \-20 resulting .\" in the scheduler mildly disfavoring the task group and +19 greatly .\" disfavoring it. .\" .\" A patch was posted on 23 Nov 2016 .\" ("sched/autogroup: Fix 64bit kernel nice adjustment"; .\" check later to see in which kernel version it lands. Za pomocą tego pliku można też zmodyfikować przydział procesora przypisany autogrupie. Robi się to zapisując liczbę z przedziału wartości \[Bq]nice\[rq] do pliku, co powoduje przypisanie wartości nice autogrupie. Dozwolony zakres to od +19 (niski priorytet) do \-20 (wysoki priorytet). Zapisanie wartości spoza tego przedziału spowoduje zgłoszenie przez \fBwrite\fP(2) błędu \fBEINVAL\fP. .P Ustawienie nice autogrupy ma takie samo znaczenie jak wartość nice procesu, jednak odnosi się do rozłożenia cykli procesora do autogrupy jako całości, w oparciu o relatywne wartości nice innych autogrup. W przypadku procesu wewnątrz autogrupy, cykle procesora jakie on otrzyma będą skutkiem łącznego oddziaływania wartości nice autogrupy (w porównaniu z innymi autogrupami) oraz wartości nice procesu (w porównaniu z innymi procesami tej samej autogrupy). .P Korzystanie z kontrolera procesora \fBcgroups\fP(7) do umieszczania procesów w grupach kontrolnych (cgroup) innych niż główna grupa kontrolna procesora przesłania efekt działania autogrupowania. .P .\" Funkcja autogrupowania grupuje jedynie procesy szeregowane według algorytmów innych niż czasu rzeczywistego (tj. dotyczy algorytmów \fBSCHED_OTHER\fP, \fBSCHED_BATCH\fP i \fBSCHED_IDLE\fP). Nie grupuje procesów szeregowanych według algorytmów czasu rzeczywistego oraz z budżetem czasu. Takie procesy są szeregowane zgodnie z zasadami opisanymi wcześniej. .SS "Wartość nice oraz szeregowanie grup" Przy szeregowaniu procesów innych niż czasu rzeczywistego (tj. szeregowanych według algorytmów \fBSCHED_OTHER\fP, \fBSCHED_BATCH\fP i \fBSCHED_IDLE\fP), dyspozytor CFS używa techniki znanej jako \[Bq]szeregowanie grup\[rq], jeśli tylko jądro skonfigurowano z opcją \fBCONFIG_FAIR_GROUP_SCHED\fP (jest to opcja typowo włączona). .P W szeregowaniu grup, wątki są szeregowane w \[Bq]grupach zadań\[rq]. Grupy zadań mają relację hierarchiczną, zakorzenioną w pierwotnej grupie zadaniowej systemu, zwanej \[Bq]główną grupą zadań\[rq]. Grupy zadań są tworzone w następujących okolicznościach: .IP \[bu] 3 Wszystkie wątki grupy kontrolnej (cgroup) procesora tworzą grupę zadań. Rodzicem tej grupy zadań jest grupa zadań odpowiadającej rodzicielskiej grupy kontrolnej. .IP \[bu] Jeśli autogrupowanie jest włączone, wszystkie wątki, które są (w sposób dorozumiany) umieszczane w autogrupie (tj. z tej samej sesji, tworzonej przez \fBsetsid\fP(2)) tworzą grupę zadań. Każda nowa autogrupa jest zatem oddzielną grupą zadań. Główna grupa zadań jest rodzicem wszystkich takich autogrup. .IP \[bu] Jeśli autogrupowanie jest włączone, główna grupa zadań składa się ze wszystkich procesów w głównej grupie kontrolnej procesora, które nie zostały w sposób dorozumiany umieszczone w nowej autogrupie. .IP \[bu] Jeśli autogrupowanie jest wyłączone, główna grupa zadań składa się ze wszystkich procesów w głównej grupie kontrolnej procesora. .IP \[bu] Jeśli wyłączono szeregowanie grup (tj. jądro skonfigurowano bez opcji \fBCONFIG_FAIR_GROUP_SCHED\fP), wszystkie procesy w systemie są jak gdyby umieszczane w jednej grupie zadań. .P Przy korzystaniu z szeregowaniu grup, wartość nice wątku ma znaczenie przy decyzjach szeregowania \fItylko względem innych wątków w tej samej grupie zadań\fP. Ma to pewne zaskakujące konsekwencje w kontekście tradycyjnego zachowania wartości nice w systemach uniksowych. W szczególności, jeśli autogrupowanie jest włączone (a tak domyślnie jest w wielu dystrybucjach), to użycie \fBsetpriority\fP(2) lub \fBnice\fP(1) wobec procesu odnosi efekt na szeregowaniu tylko względem innych procesów wykonywanych w tej samej sesji (zwykle: tym samym oknie terminala). .P .\" More succinctly: the nice(1) command is in many cases a no-op since .\" Linux 2.6.38. .\" Co za tym idzie, w przypadku dwóch procesów (przykładowo), które są jedynymi procesami ograniczonymi wydajnością procesora, występujących w dwóch sesjach (np. różnych oknach terminala, zatem każde z zadań jest przypisanych do innej autogrupy), \fImodyfikacja wartość nice procesu w jednej z sesji nie odnosi skutku\fP wobec decyzji dyspozytora odnoszącej się do procesu w drugiej sesji. Przydatnym obejściem tego nieintuicyjnego zachowania może być polecenie, takie jak poniższe, modyfikujące wartość nice autogrupy \fIwszystkich\fP procesów w sesji terminala: .P .in +4n .EX $\fB echo 10 > /proc/self/autogroup\fP .EE .in .SS "Funkcje czasu rzeczywistego w jądrze Linux z głównej serii" .\" The archaeologist knows about v2.6.9-mm1-V0.1-realtime-preempt Od Linuksa 2.6.18, Linux jest stopniowo wzbogacany o zdolności czasu rzeczywistego; większość pochodzi z uprzedniego zestawu łatek \fIrealtime\-preempt\fP. Łatki są nazywane następująco: .P .in +4n .EX patch\-\fIwersjajądra\fP\-rt\fIwersjałatki\fP .EE .in .P i można je pobrać ze strony .UR http:\://www.kernel.org\:/pub\:/linux\:/kernel\:/projects\:/rt/ .UE lub klonując drzewo git .UR https:\://git.kernel.org\:/pub\:/scm\:/linux\:/kernel\:/git\:/rt\:/linux\-stable\-rt.git .UE . Poszczególne wydania są utrzymywane tak długo, jak dane jądro LTS. .P Od Linuksa 6.12 można włączyć wywłaszczanie czasu rzeczywistego bez konieczności instalowania łatek. \fIrealtime\-patch\fP wciąż będzie istniał, zapewniając obsługę jeszcze niezintegrowanych architektur, sterowników oraz funkcji w trakcie rozwoju. .P Od Linux 6.13 możliwości czasu rzeczywistego są zapewniane jako opcja, a nie model wywłaszczania. Po tej zmianie, dostępne są następujące modele wywłaszczania: \fBCONFIG_PREEMPT_NONE\fP, \fBCONFIG_PREEMPT_VOLUNTARY\fP, \fBCONFIG_PREEMPT\fP oraz \fBCONFIG_PREEMPT_LAZY\fP. Możliwości czasu rzeczywistego można włączyć opcją \fBCONFIG_PREEMPT_RT\fP, a model wywłaszczania można ustawić na \fBCONFIG_PREEMPT\fP lub \fBCONFIG_PREEMPT_LAZY\fP. Ten drugi rzadziej wywłaszcza zadania \fBSCHED_NORMAL\fP, próbując ograniczyć wywłaszczanie posiadaczy blokad. Nie ma to wpływu na zadania czasu rzeczywistego. .P Po włączeniu \fBCONFIG_PREEMPT_RT\fP, Linux staje się standardowym systemem operacyjnym czasu rzeczywistego. Algorytmy szeregowania \fBSCHED_FIFO\fP, \fBSCHED_RR\fP i \fBSCHED_DEADLINE\fP są wówczas stosowane do uruchamiania wątku z prawdziwym priorytetem czasu rzeczywistego oraz zapewnionym minimalnym opóźnieniem szeregowania najgorszego przypadku. .SH UWAGI Do ograniczania użycia procesora przez grupy procesów można stosować kontroler procesora \fBcgroups\fP(7). .P Pierwotnie, standardowy Linux był pomyślany jako uniwersalny system operacyjny, zdolny do obsługi procesów tła, aplikacji interaktywnych oraz mniej wymagających aplikacji czasu rzeczywistego (aplikacji, które zwykle muszą mieścić się w ograniczeniach czasowych). Choć Linux 2.6 umożliwił wywłaszczanie przez jądro, a nowo wprowadzony dyspozytor O(1) zapewnia, że czas potrzebny na uszeregowanie jest stały i deterministyczny, niezależnie od liczby aktywnych zadań, prawdziwe zachowanie czasu rzeczywistego nie było dostępne do Linuksa 2.6.17. .SH "ZOBACZ TAKŻE" .ad l .nh \fBchcpu\fP(1), \fBchrt\fP(1), \fBlscpu\fP(1), \fBps\fP(1), \fBtaskset\fP(1), \fBtop\fP(1), \fBgetpriority\fP(2), \fBmlock\fP(2), \fBmlockall\fP(2), \fBmunlock\fP(2), \fBmunlockall\fP(2), \fBnice\fP(2), \fBsched_get_priority_max\fP(2), \fBsched_get_priority_min\fP(2), \fBsched_getaffinity\fP(2), \fBsched_getparam\fP(2), \fBsched_getscheduler\fP(2), \fBsched_rr_get_interval\fP(2), \fBsched_setaffinity\fP(2), \fBsched_setparam\fP(2), \fBsched_setscheduler\fP(2), \fBsched_yield\fP(2), \fBsetpriority\fP(2), \fBpthread_getaffinity_np\fP(3), \fBpthread_getschedparam\fP(3), \fBpthread_setaffinity_np\fP(3), \fBsched_getcpu\fP(3), \fBcapabilities\fP(7), \fBcpuset\fP(7) .ad .P \fIProgramming for the real world \- POSIX.4\fP autorstwa Billa O.\& Gallmeistera, O'Reilly & Associates, Inc., ISBN 1\-56592\-074\-0. .P .UR https:\://docs.kernel.org/\:scheduler Dokumentacja dyspozytora w jądrze Linux .UE . .P Warte przeglądnięcia na stronie: .UR https:\://wiki.linuxfoundation.org/\:realtime/\:start .UE .PP .SH TŁUMACZENIE Tłumaczenie niniejszej strony podręcznika: Michał Kułach . .PP Niniejsze tłumaczenie jest wolną dokumentacją. Bliższe informacje o warunkach licencji można uzyskać zapoznając się z .UR https://www.gnu.org/licenses/gpl-3.0.html GNU General Public License w wersji 3 .UE lub nowszej. Nie przyjmuje się ŻADNEJ ODPOWIEDZIALNOŚCI. .PP Błędy w tłumaczeniu strony podręcznika prosimy zgłaszać na adres listy dyskusyjnej .MT manpages-pl-list@lists.sourceforge.net .ME .