ExternalVendorCode/genode
1
0
Fork 0
mirror of https://github.com/genodelabs/genode.git synced 2024-12-22 06:57:51 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Revert "Use strictly-typed Microseconds for Libc timeout scheduling"

Browse Source 
This reverts commit 4808565a28afe9ff248fb5c98aceb6f8d3e791c1.
This commit is contained in:
Christian Helmuth 2018-12-03 14:37:54 +01:00 committed by Norman Feske
parent e1b27885f9
commit 8236a18260
5 changed files with 58 additions and 66 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
repos/libports/lib/symbols/libc
View File

@ -948,7 +948,6 @@ _ZN16Pthread_registry6insertEP7pthread T
_ZN16Pthread_registry6removeEP7pthread T
_ZN16Pthread_registry8containsEP7pthread T
_ZN4Libc14pthread_createEPP7pthreadPFPvS3_ES3_mPKcPN6Genode11Cpu_sessionENS8_8Affinity8LocationE T
_ZN4Libc7suspendERNS_15Suspend_functorEN6Genode12MicrosecondsE T
#
# Libc plugin interface

8
repos/libports/src/lib/libc/nanosleep.cc
View File

@ -19,14 +19,12 @@
extern "C" __attribute__((weak))
int _nanosleep(const struct timespec *req, struct timespec *rem)
{
using namespace Libc;
unsigned long sleep_ms = req->tv_sec*1000 + req->tv_nsec/1000000;
Microseconds sleep_us(req->tv_sec*1000*1000 + req->tv_nsec/1000);
if (!sleep_us.value) return 0;
if (!sleep_ms) return 0;
struct Check : Libc::Suspend_functor { bool suspend() override { return true; } } check;
do { sleep_us = Libc::suspend(check, sleep_us); } while (sleep_us.value);
do { sleep_ms = Libc::suspend(check, sleep_ms); } while (sleep_ms);
if (rem) {
rem->tv_sec = 0;

8
repos/libports/src/lib/libc/select.cc
View File

@ -220,8 +220,6 @@ __attribute__((weak))
_select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds,
struct timeval *tv)
{
using namespace Libc;
fd_set in_readfds, in_writefds, in_exceptfds;
Genode::Constructible<Libc::Select_cb> select_cb;
@ -264,10 +262,10 @@ _select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds,
{
timeval const *_tv;
bool const valid { _tv != nullptr };
Microseconds duration {
valid ? (unsigned long)_tv->tv_sec*1000 + _tv->tv_usec : 0UL };
unsigned long duration {
valid ? (unsigned long)_tv->tv_sec*1000 + _tv->tv_usec/1000 : 0UL };
bool expired() const { return valid && duration.value == 0; };
bool expired() const { return valid && duration == 0; };
Timeout(timeval *tv) : _tv(tv) { }
} timeout { tv };

90
repos/libports/src/lib/libc/task.cc
View File

@ -49,7 +49,7 @@ namespace Libc {
class Timeout_handler;
class Io_response_handler;
using Genode::Duration;
using Genode::Microseconds;
}
@ -217,7 +217,7 @@ struct Libc::Timer
Timer(Genode::Env &env) : _timer(env) { }
Duration curr_time()
Genode::Duration curr_time()
{
return _timer.curr_time();
}
@ -227,9 +227,9 @@ struct Libc::Timer
return Microseconds(1000*timeout_ms);
}
static Microseconds max_timeout()
static unsigned long max_timeout()
{
return Microseconds(~0UL/(1000*1000));
return ~0UL/1000;
}
};
@ -263,12 +263,12 @@ struct Libc::Timeout
::Timer::One_shot_timeout<Timeout> _timeout;
bool _expired = true;
Duration _absolute_timeout { Microseconds(0) };
unsigned long _absolute_timeout_ms = 0;
void _handle(Duration now)
{
_expired = true;
_absolute_timeout = Duration(Microseconds(0));
_absolute_timeout_ms = 0;
_handler.handle_timeout();
}
@ -279,23 +279,24 @@ struct Libc::Timeout
_timeout(_timer_accessor.timer()._timer, *this, &Timeout::_handle)
{ }
void start(Microseconds timeout_us)
void start(unsigned long timeout_ms)
{
_absolute_timeout = _timer_accessor.timer().curr_time();
_absolute_timeout.add(timeout_us);
Milliseconds const now = _timer_accessor.timer().curr_time().trunc_to_plain_ms();
_timeout.schedule(timeout_us);
_expired = false;
_absolute_timeout_ms = now.value + timeout_ms;
_timeout.schedule(_timer_accessor.timer().microseconds(timeout_ms));
}
Microseconds duration_left() const
unsigned long duration_left() const
{
Duration const now = _timer_accessor.timer().curr_time();
Milliseconds const now = _timer_accessor.timer().curr_time().trunc_to_plain_ms();
if (_expired || _absolute_timeout.less_than(now))
return Microseconds(0);
if (_expired || _absolute_timeout_ms < now.value)
return 0;
return Microseconds(_absolute_timeout.trunc_to_plain_us().value
- now.trunc_to_plain_us().value);
return _absolute_timeout_ms - now.value;
}
};
@ -316,16 +317,16 @@ struct Libc::Pthreads
_timeout.construct(_timer_accessor, *this);
}
Pthread(Timer_accessor &timer_accessor, Microseconds timeout)
Pthread(Timer_accessor &timer_accessor, unsigned long timeout_ms)
: _timer_accessor(timer_accessor)
{
if (timeout.value > 0) {
if (timeout_ms > 0) {
_construct_timeout_once();
_timeout->start(timeout);
_timeout->start(timeout_ms);
}
}
Microseconds duration_left()
unsigned long duration_left()
{
_construct_timeout_once();
return _timeout->duration_left();
@ -353,9 +354,9 @@ struct Libc::Pthreads
p->lock.unlock();
}
Microseconds suspend_myself(Suspend_functor & check, Microseconds timeout_us)
unsigned long suspend_myself(Suspend_functor & check, unsigned long timeout_ms)
{
Pthread myself { timer_accessor, timeout_us };
Pthread myself { timer_accessor, timeout_ms };
{
Genode::Lock::Guard g(mutex);
@ -378,7 +379,7 @@ struct Libc::Pthreads
}
}
return timeout_us.value > 0 ? myself.duration_left() : Microseconds(0);
return timeout_ms > 0 ? myself.duration_left() : 0;
}
};
@ -502,13 +503,13 @@ struct Libc::Kernel
: _timer_accessor(timer_accessor), _kernel(kernel)
{ }
void timeout(Microseconds timeout)
void timeout(unsigned long timeout_ms)
{
_construct_timeout_once();
_timeout->start(timeout);
_timeout->start(timeout_ms);
}
Microseconds duration_left()
unsigned long duration_left()
{
_construct_timeout_once();
return _timeout->duration_left();
@ -552,7 +553,7 @@ struct Libc::Kernel
kernel->_app_code->execute();
kernel->_app_returned = true;
kernel->_suspend_main(check, Microseconds(0));
kernel->_suspend_main(check, 0);
}
bool _main_context() const { return &_myself == Genode::Thread::myself(); }
@ -585,8 +586,8 @@ struct Libc::Kernel
_longjmp(_user_context, 1);
}
Microseconds _suspend_main(Suspend_functor &check,
Microseconds timeout)
unsigned long _suspend_main(Suspend_functor &check,
unsigned long timeout_ms)
{
/* check that we're not running on libc kernel context */
if (Thread::mystack().top == _kernel_stack) {
@ -596,10 +597,10 @@ struct Libc::Kernel
}
if (!check.suspend())
return Microseconds(0);
return 0;
if (timeout.value > 0)
_main_timeout.timeout(timeout);
if (timeout_ms > 0)
_main_timeout.timeout(timeout_ms);
if (!_setjmp(_user_context)) {
_valid_user_context = true;
@ -627,8 +628,7 @@ struct Libc::Kernel
_longjmp(_kernel_context, 1);
}
return timeout.value > 0
? _main_timeout.duration_left() : Microseconds(0);
return timeout_ms > 0 ? _main_timeout.duration_left() : 0;
}
public:
@ -721,19 +721,19 @@ struct Libc::Kernel
/**
* Suspend this context (main or pthread)
*/
Microseconds suspend(Suspend_functor &check, Microseconds timeout_us)
unsigned long suspend(Suspend_functor &check, unsigned long timeout_ms)
{
if (timeout_us.value > 0
&& timeout_us.value > _timer_accessor.timer().max_timeout().value) {
if (timeout_ms > 0
&& timeout_ms > _timer_accessor.timer().max_timeout()) {
Genode::warning("libc: limiting exceeding timeout of ",
timeout_us, " us to maximum of ",
_timer_accessor.timer().max_timeout(), " us");
timeout_ms, " ms to maximum of ",
_timer_accessor.timer().max_timeout(), " ms");
timeout_us = min(timeout_us, _timer_accessor.timer().max_timeout());
timeout_ms = min(timeout_ms, _timer_accessor.timer().max_timeout());
}
return _main_context() ? _suspend_main(check, timeout_us)
: _pthreads.suspend_myself(check, timeout_us);
return _main_context() ? _suspend_main(check, timeout_ms)
: _pthreads.suspend_myself(check, timeout_ms);
}
void dispatch_pending_io_signals()
@ -751,7 +751,7 @@ struct Libc::Kernel
}
}
Duration current_time()
Genode::Duration current_time()
{
return _timer_accessor.timer().curr_time();
}
@ -873,13 +873,13 @@ static void resumed_callback() { kernel->entrypoint_resumed(); }
void Libc::resume_all() { kernel->resume_all(); }
Libc::Microseconds Libc::suspend(Suspend_functor &s, Microseconds timeout_us)
unsigned long Libc::suspend(Suspend_functor &s, unsigned long timeout_ms)
{
if (!kernel) {
error("libc kernel not initialized, needed for suspend()");
exit(1);
}
return kernel->suspend(s, timeout_us);
return kernel->suspend(s, timeout_ms);
}

7
repos/libports/src/lib/libc/task.h
View File

@ -26,8 +26,6 @@
namespace Libc {
using Genode::Microseconds;
/**
* Resume all user contexts
*
@ -38,7 +36,7 @@ namespace Libc {
/**
* Suspend the execution of the calling user context
*
* \param timeout maximum time to stay suspended in microseconds,
* \param timeout_ms maximum time to stay suspended in milliseconds,
* 0 for infinite suspend
*
* \return remaining duration until timeout,
@ -49,8 +47,7 @@ namespace Libc {
* resumed the user context execution.
*/
struct Suspend_functor { virtual bool suspend() = 0; };
Microseconds suspend(Suspend_functor &,
Microseconds timeout = Microseconds(0UL));
unsigned long suspend(Suspend_functor &, unsigned long timeout_ms = 0UL);
void dispatch_pending_io_signals();