prioritás áramlások
prioritás áramlások
Van esély arra, hogy ez az, ahol én utasítja korábban, mint más helyeken :)
Azt működnek Linux alatt „th, és azt meg kell változtatni a szál prioritás próbálom tenni a következőképpen .:
#include
#include
static void * my_thread (void * arg)
alvás (1);
>
int main (void)
pthread_t menet;
int prioritás;
int politikát;
struct sched_param param;
int res;
pthread_create (menet, NULL, my_thread, NULL);
res = pthread_getschedparam (menet, politika, param);
priority = param.sched_priority;
printf ( „res =. # XA0; politika =. # XA0; priority = \ n”, res, politika, prioritás) .;
param.sched_priority = 2;
politika = SCHED_OTHER;
res = pthread_setschedparam (menet, politika, param);
printf ( "res = \ n.", RES);
Az eredmény:
res = 0 politika = 0 = 0 prioritás
res = 22
Code 22 annyit tesz, mint „Érvénytelen paraméter”. Mit csinálok rosszul?
érdemes megnézni a visszatérési érték a funkciót. Abban az időben az áramlási paraméterek még mindig létezik?
Kösz a linket.
res = pthread_attr_init (attR);
attr .__ schedpolicy = SCHED_FIFO; # XA0; // SCHED_FIFO = 1
attr .__ schedparam.sched_priority = 5;
res = pthread_create (menet, attr, my_thread, menet);
res = pthread_getschedparam (menet, politika, param);
printf ( „rs =. # XA0; politika =. # XA0; priority = \ n”, res, politika ,. # XA0; param.sched_priority);
Azt az eredményt kapjuk:
res = 0 politika = 0 = 0 prioritás
Miért csak írt itt. )
Már újraindul 5-ször azért, mert a finomítások menettel lóg szorosan rendszer. Bár prioritás kaptam változtatni))
#include
#include
#include
#include
#include
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int a [2] =;
static void * my_thread (void * arg)
míg a (1) # XA0; pthread_mutex_lock (mutexet);
# XA0, egy [(int) arg] = a [(int) arg] + 1;
# XA0; pthread_mutex_unlock (mutexet);
# XA0; pthread_yield ();
# XA0; alvás (2); // Ha eltávolítja a program lefagy a rendszer;)
>
>
int main (void)
pthread_t thread1, thread2;
int prioritás;
int politika newprio;
struct sched_param param;
int ret;
printf ( ".... \ n", EPERM, EINVAL, ENOTSUP, ESRCH);
printf ( "\ n ...", SCHED_OTHER, SCHED_RR, SCHED_FIFO);
politika = SCHED_RR;
param.sched_priority = 2;
ret = sched_setscheduler (getpid (), politika, param);
ha (ret == 0) # XA0; printf ( "Set sched folyamat sikere \ n");
> Else if (ret == EPERM)
# XA0; printf ( "No Permission \ n");
>
pthread_create (thread1, NULL, my_thread, (void *) (0));
pthread_create (thread2, NULL, my_thread, (void *) (1));
# XA0; # XA0; # XA0; # XA0; param.sched_priority = 2;
# XA0; # XA0; # XA0; # XA0; politika = SCHED_RR;
# XA0; # XA0; # XA0; # XA0; ret = pthread_setschedparam (thread1, politika, param);
# XA0; ha (RET == 0) # XA0; printf ( "Set sched 1 sikert \ n");
> más # XA0; printf ( "meghibásodott 1 \ n");
>
ret = pthread_getschedparam (thread1, politika, param);
ha (ret == 0) # XA0; printf ( "Thread1 prioritás \ n.", Param.sched_priority);
>
# XA0; # XA0; # XA0; # XA0; param.sched_priority = 1;
# XA0; # XA0; # XA0; # XA0; politika = SCHED_RR;
# XA0; # XA0; # XA0; # XA0; ret = pthread_setschedparam (thread2, politika, param);
# XA0; ha (RET == 0) # XA0; printf ( "Set sched 2 sikert \ n");
> más # XA0; printf ( "meghibásodott 2 \ n");
>
ret = pthread_getschedparam (thread2, politika, param);
ha (ret == 0) # XA0; printf ( "Thread2 prioritás \ n.", Param.sched_priority);
>
míg a (1) # XA0; pthread_mutex_lock (mutexet);
# XA0; printf (, a [0], a [1] "\ t \ n ..");
# XA0; pthread_mutex_unlock (mutexet);
# XA0; usleep (5000);
>
Én még mit ért. Igyekszem, hogy vizuálisan látni, hogy egy szál magasabb prioritású, de eddig csak az kap, hogy indítsa újra minden alkalommal, amikor futtatni :)
Ie ha fel a politika SCHED_RR vagy SCHED_FIFO, a menet a legmagasabb prioritással kerül végrehajtásra, amíg kénytelen ne szakítsa meg (például a futás pthread_yield). De hogyan, hogy a különböző prioritások folyik SCHED_OTHER politika, ha nem tudja megváltoztatni a prioritást, nem világos számomra :(
Általában, ha jól értem, akkor az alkalmazás maga kell ellenőrizni, hogy azt akarja, hogy fordítsanak időt szálak között. A pontos idő eloszlását, vannak politikák dinamikus prioritás (SCHED_RR / SCHED_FIFO), mert annak szükségességét, hogy a pontatlan SCHED_OTHER lehetősége nélkül, hogy különböző dinamikus prioritás folyik.
A végén, ez az, amit kaptam:
#include
#include
#include
#include
#include
statikus pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
static int thread_vars [2] =;
statikus safe_inc (int * x)
pthread_mutex_lock (mutex);
* X + = 1;
pthread_mutex_unlock (mutex);
>
static void * thread_proc (void * arg)
míg a (1)
# XA0; safe_inc (thread_vars [(int) arg]);
# XA0; if ((Int) arg == 0) usleep (1);
>
>
int main (void)
pthread_t thread1, thread2;
pthread_create (thread1, NULL, thread_proc, (void *) (0));
pthread_create (thread2, NULL, thread_proc, (void *) (1));
int x, y;
míg a (1)
# XA0; pthread_mutex_lock (mutexet);
# XA0; x = thread_vars [0];
# XA0; y = thread_vars [1];
# XA0; pthread_mutex_unlock (mutexet);
# XA0;
# XA0; printf (, x, y "\ t \ n ..");
# XA0; usleep (100);
>
Ie 2. áramlását, és egyikük mesterségesen lassítja hívás usleep. A második automatikusan megkapja a „magasabb prioritás”.
Úgy tűnik, hogy a politika nem változott, és mindig SCHED_OTHER. Streams kapott időrés függ a paraméter szép vonás (1), - minél nagyobb az érték, annál kisebb a kvantum. Ez, persze, nem valós időben, hanem azért is, élni lehet.
Köszönöm a segítséget, különösen szép.
Van egy politikai változás, de rialtaymovoy politika úgy tűnik, hogy lehet tréfálni, és nem tudtam neki szelíd. Egy szép megváltoztatja a prioritás a folyamat, és ez az, ahol beállíthatja a dinamikus prioritás képest más folyamatok és minden mást, minden működik. Tőle természetesen függ és a kiosztott időrés.
Remélem, legalább valamit segíteni :) A magam részéről sokat tanultam :)
Játszottam egy kicsit, de kontrgollere amelyre írok a programot. Itt van, mi történik:
1. A felhasználói módban csak SCHED_OTHER. Ez az, amit láttam tegnap a Red Hat.
2. A felügyelő mód munka és más politikusok. Ebben a módban már megkezdte a vezérlő.
3. Minél nagyobb a paraméter prioritása, a magasabb prioritást. Valamilyen oknál fogva azt gondoltam az ellenkezőjét.
A végleges változat a teszt a vezérlő működik pontosan, mint várták. Ebben, tettem a késedelem az alacsony prioritású szál, mert csak elfedi, hogy mi történik. Továbbá, nem kell, és mutexes, mert int műveletek atomi - ez az, amit ez, és int!
Itt a szöveg (a folyamat megszakad a Ctrl-C, nem érdekel, mert a vezérlő I reloaded elég gyorsan):
#include
#include
#include
#include
#include
static void * my_thread (void * arg)
int dermedt = (int) arg;
int politikát;
struct sched_param param;
int count = 0;
int res;
politika = SCHED_FIFO;
ha (eltompult == 0)
# XA0; param.sched_priority = 5;
más
# XA0; param.sched_priority = 10;
res = sched_setscheduler (getpid (), politika, param);
int main (void)
pthread_t thread1, thread2;
int prioritás;
int politika newprio;
struct sched_param param;
int ret;
ret = pthread_getschedparam (thread1, politika, param);
politika = SCHED_FIFO;
param.sched_priority = 30;
ret = sched_setscheduler (getpid (), politika, param);
pthread_create (thread1, NULL, my_thread, (void *) 0);
pthread_create (thread2, NULL, my_thread, (void *) 1);
míg a (1) # XA0; printf (, a [0], a [1] "\ t \ n ..");
# XA0; usleep (1000);
>
_uw_ # XA0; (03.01.07 10:27) [11]
Játszottam egy kicsit, de kontrg Oller
Itt után! Néhány generáció kiszállt :)
> _uw_ # XA0; (03.01.07 10:27) [11]
Én ezt a kódot lóg a rendszer :) Nos, ez folyamat eszi le az összes CPU időt, a konzol nem is volt ideje, hogy bármit, azonnal megfagy, és a „ment” csak Alt + SysRq + b. Nem tudom megérteni, hogy miért és hogyan, hogy egy emberi :(
Vagy rialtaymovye politika célja, hogy amellett, hogy más rialtaymovyh folyamatot nem kell elvégezni? Ezután valószínűleg rutinfeladatokat kell használni mesterséges szünet, mint én [8] javasolt?
> Én ezt a kódot lóg rendszer
Van más kernel, valószínűleg. Meg lehet próbálni csökkenteni param.sched_priority.
ahogy meg van írva az ember sched_setparam. maximális prioritás érték alkalmazásával érhetjük s ched_get_priority_max
Igen, elolvastam az egészet :) És mindent megpróbáltak. Ez lóg minden értéket. Talán buggy kernel fogott persze, de valami mélyen meg vagyok kétség. Most, a kedvéért kísérlet, próbáld ki a másik mag.
Ahogy az várható volt, ez hozta 0 0 és felakasztotta. (
Nos igen, és mit akar. Létrehoz 2 áramot a legmagasabb prioritású, amelynek végrehajtása nem lehet megszakítani és szeretne valamit nyomtatni egy patak alacsony prioritású
Megszakított usleep „ohm. De ez nem elég, mert ha jól értem, minden olyan eljárás, valós idejű politika végrehajtásra kerül, mielőtt az összes többi. Tehát ezeket politika az asztalon nem lehetséges.
Ott általában 3 áramlás fő prioritása 30. Egyértelmű, hogy nem hagyja el a rendszert egy esélyt szerezni legalább egy szelet CPU időt. Van egy nem értem, hogy miért _uw_ működik, azt mondta :)
Memória: 0.78 MB
Idő: 0,046 c