Skotský vývojář Mike Lothian pozastavil vývoj svého otevřeného ovladače Vino (nedostupné) pro dokovací stanice DisplayLink poté, co mu Synaptics v reakci na žádost o pomoc pohrozil žalobou kvůli údajnému porušování patentů. Firma nejprve předložila seznam 125 patentů bez specifikace, které konkrétně měl ovladač porušovat, a následně požadovala 25 tisíc dolarů za náklady na jejich přiřazení ke kódu s hrozbou, že se tato částka bude
… více »Byla vydána OpenIndiana 2026.10. Unixový operační systém OpenIndiana (Wikipedie) vychází z OpenSolarisu (Wikipedie).
Americký výrobce polovodičů onsemi (ON Semiconductor) zrušil plány na rozšíření výroby v rožnovském závodě v Česku za dvě miliardy dolarů (podle aktuálního kurzu zhruba 43,5 mld. Kč). Důvodem je vývoj na trhu.
O víkendu probíhá na FIT VUT v Brně konference OpenAlt 2026 o otevřeném softwaru a datech, IT bezpečnosti, DIY a IoT. Na programu je spousta zajímavých přednášek. Pokud jste v Brně, stavte se. Vstup zdarma. Přednášky lze sledovat i online na VHSky a YouTube.
Řešení dotazu:
…sleep(3) may be implemented using SIGALRM; mixing calls to alarm() and sleep(3) is a bad idea.…
Dala by se v hlavní programové smyčce nahradit funkce sleep za jiný mechanismus?Jinak na modernich jadrech by sel take pouzit cekani na timerfd, viz treba http://www.kernel.org/doc/man-pages/online/pages/man2/timerfd_create.2.html
sleep() nebo nanosleep(). Luboš měl ale IMHO na mysli to, že někdy autoři programů místo pasivního čekání na nějakou událost využívají smyčku, která se v pravidelných intervalech ptá, jestli už událost nastala. Při krátkém intervalu se tím zbytečně zatěžují zdroje, při dlouhém se zase prodlužuje reakční doba. Někdy to samozřejmě jinak dělat nejde, ale často se to z neznalosti nebo lenosti používá, i když mechanismy pro pasivní čekání existují.
nanosleep() podle manuálu pro krátké intervaly čekal aktivně
I kdyby ano, tady se bavíme o náhradě za sleep(), takže o takový interval zcela určitě nejde.
Každopádně s prostředky pro sleep() bych si moc starostí nedělal, test jedné podmínky jednou za několik sekund (granularita funkce sleep) je zanedbatelná zátěž.
Tady si asi nerozumíme. Neměl jsem na mysli zátěž funkce sleep() samotné, ale o ty periodické kontroly, tj. konstrukce typu
while (!ready()) {
usleep(100);
}
když na něco čekáte. Pokud ten interval bude příliš krátký, budou opakované kontroly příliš zatěžovat procesor (a možná i něco jiného). Bude-li příliš dlouhý, pak máte příliš dlouhou odezvu. Pokud existují prostředky, jak se nechat probudit až tehdy, když je podmínka splněná (a hned, jakmile je splněná), měla by jim být dána přednost.
Pokud ti přijde nějaký signál, sleep bude přerušen a ty nebudeš vědět jak dlouho ještě čekat.man sleep(3) rika neco jineho:
Zero if the requested time has elapsed, or the number of seconds left to sleep, if the call was interrupted by a signal handler.
int
own_sleep (time_t seconds, time_t useconds)
{
#if LINUX
struct timeval interval;
if (seconds < 0)
seconds = 0;
if (useconds < 0)
useconds = 0;
if (seconds == 0 && useconds == 0)
return -1;
memset(&interval, 0, sizeof(interval));
interval.tv_sec = seconds;
interval.tv_usec = useconds;
return select (FD_SETSIZE, NULL, NULL, NULL, &interval);
#endif
#if !(defined __MINGW32__ || defined _MSC_VER)
struct timeval now, deadline;
gettimeofday (&deadline, NULL);
#if 0
deadline.tv_usec += usec;
deadline.tv_sec += deadline.tv_usec / 1000000;
deadline.tv_usec %= 1000000;
#else
deadline.tv_sec += useconds;
deadline.tv_usec += seconds;
#endif
do
{
gettimeofday (&now, NULL);
}
while ((now.tv_sec < deadline.tv_sec) ||
(now.tv_sec == deadline.tv_sec && now.tv_usec < deadline.tv_usec));
#else
/* MinGW has no gettimeofday(). ftime() seems to be the best alternative as I
* don't know of any standard Windows function with microsecond accuracy. I
* should have a look at the Cygwin source code... - dbjh */
struct timeb tb;
int32_t int now, deadline;
ftime (&tb);
deadline = tb.time * 1000 + tb.millitm + useconds / 1000;
do
{
ftime (&tb);
now = tb.time * 1000 + tb.millitm;
}
while (now < deadline);
#endif
}
zakladni problem je v tom, ze kazde aktivni volani sleep, za pomoci dodatecnych funkci vytvari rezii na CPU a na volani prislusnych prostredku. Nejlepsi je pouziti timeoutu pro uvedeny select().
pthread_mutex_lock(mutex);
clock_gettime(CLOCK_REALTIME, &abstime);
abstime.tv_nsec += msec * 1000000;
abstime.tv_sec += sec;
if (abstime.tv_nsec > 1000000000UL) {
abstime.tv_nsec %= 1000000000UL;
abstime.tv_sec += 1;
}
rc = pthread_cond_timedwait(cond, mutex, &abstime);
if (rc != ETIMEDOUT) WARN("Predcasny timeout (rc=%d)", rc);
pthread_mutex_unlock(mutex);
Před použitím se musely inicializovat proměnné "mutex" a "cond". Ale zase pomocí funkce pthread_cond_signal() šlo čekání okamžitě zrušit.
Tiskni
Sdílej: