X-Git-Url: https://git.cweiske.de/enigma2.git/blobdiff_plain/842dabf727814691bfd949ac4d910ce04c32b887..6c04aa3fe1a0026aac3a17fb45e0f2de63142548:/lib/base/ebase.cpp diff --git a/lib/base/ebase.cpp b/lib/base/ebase.cpp index addd1b88..93bfd342 100644 --- a/lib/base/ebase.cpp +++ b/lib/base/ebase.cpp @@ -24,7 +24,7 @@ void eSocketNotifier::start() stop(); context.addSocketNotifier(this); - state=1; + state=2; // running but not in poll yet } void eSocketNotifier::stop() @@ -45,6 +45,7 @@ void eTimer::start(long msek, bool singleShot) bSingleShot = singleShot; interval = msek; gettimeofday(&nextActivation, 0); + nextActivation.tv_sec -= context.getTimeOffset(); // eDebug("this = %p\nnow sec = %d, usec = %d\nadd %d msec", this, nextActivation.tv_sec, nextActivation.tv_usec, msek); nextActivation += (msek<0 ? 0 : msek); // eDebug("next Activation sec = %d, usec = %d", nextActivation.tv_sec, nextActivation.tv_usec ); @@ -59,6 +60,7 @@ void eTimer::startLongTimer( int seconds ) bActive = bSingleShot = true; interval = 0; gettimeofday(&nextActivation, 0); + nextActivation.tv_sec -= context.getTimeOffset(); // eDebug("this = %p\nnow sec = %d, usec = %d\nadd %d sec", this, nextActivation.tv_sec, nextActivation.tv_usec, seconds); if ( seconds > 0 ) nextActivation.tv_sec += seconds; @@ -116,184 +118,137 @@ ePtrList eMainloop::existing_loops; void eMainloop::addSocketNotifier(eSocketNotifier *sn) { - notifiers.insert(std::pair (sn->getFD(), sn)); + int fd = sn->getFD(); + ASSERT(notifiers.find(fd) == notifiers.end()); + notifiers[fd]=sn; } void eMainloop::removeSocketNotifier(eSocketNotifier *sn) { - for (std::multimap::iterator i = notifiers.find(sn->getFD()); - i != notifiers.end(); - ++i) - if (i->second == sn) - return notifiers.erase(i); + int fd = sn->getFD(); + std::map::iterator i(notifiers.find(fd)); + if (i != notifiers.end()) + return notifiers.erase(i); eFatal("removed socket notifier which is not present"); } -int eMainloop::processOneEvent(unsigned int user_timeout, PyObject **res, PyObject *additional) +int eMainloop::processOneEvent(unsigned int twisted_timeout, PyObject **res, ePyObject additional) { int return_reason = 0; /* get current time */ - timeval now; - gettimeofday(&now, 0); - m_now_is_invalid = 0; - + if (additional && !PyDict_Check(additional)) eFatal("additional, but it's not dict"); - + if (additional && !res) eFatal("additional, but no res"); - - int poll_timeout = -1; /* infinite in case of empty timer list */ - - if (m_timer_list) + + long poll_timeout = -1; /* infinite in case of empty timer list */ + + if (!m_timer_list.empty() || twisted_timeout > 0) { - singleLock s(recalcLock); - poll_timeout = timeval_to_usec(m_timer_list.begin()->getNextActivation() - now); - /* if current timer already passed, don't delay infinite. */ - if (poll_timeout < 0) - poll_timeout = 0; - - /* convert us to ms */ - poll_timeout /= 1000; + applyTimeOffset(); + if (!m_timer_list.empty()) + { + /* process all timers which are ready. first remove them out of the list. */ + while (!m_timer_list.empty() && (poll_timeout = timeout_usec( m_timer_list.begin()->getNextActivation() ) ) <= 0 ) + { + m_timer_list.begin()->activate(); + applyTimeOffset(); + } + if (poll_timeout < 0) + poll_timeout = 0; + else /* convert us to ms */ + poll_timeout /= 1000; + } } - - if ((user_timeout > 0) && (poll_timeout > 0) && ((unsigned int)poll_timeout > user_timeout)) + + if ((twisted_timeout > 0) && (poll_timeout > 0) && ((unsigned int)poll_timeout > twisted_timeout)) { - poll_timeout = user_timeout; + poll_timeout = twisted_timeout; return_reason = 1; } - - int ret = 0; - - if (poll_timeout) + + int nativecount=notifiers.size(), + fdcount=nativecount, + ret=0; + + if (additional) + fdcount += PyDict_Size(additional); + + // build the poll aray + pollfd pfd[fdcount]; // make new pollfd array + std::map::iterator it = notifiers.begin(); + int i=0; + for (; i < nativecount; ++i, ++it) { - std::multimap::iterator it; - std::map fd_merged; - std::map::const_iterator fd_merged_it; - - for (it = notifiers.begin(); it != notifiers.end(); ++it) - fd_merged[it->first] |= it->second->getRequested(); - - fd_merged_it = fd_merged.begin(); - - int nativecount, fdcount; - - nativecount = fdcount = fd_merged.size(); - - if (additional) - { - additional = PyDict_Items(additional); - fdcount += PyList_Size(additional); - } + it->second->state = 1; // running and in poll + pfd[i].fd = it->first; + pfd[i].events = it->second->getRequested(); + } - // build the poll aray - pollfd* pfd = new pollfd[fdcount]; // make new pollfd array - - for (int i=0; i < nativecount; i++, fd_merged_it++) - { - pfd[i].fd = fd_merged_it->first; - pfd[i].events = fd_merged_it->second; - } - - if (additional) - { - for (int i=0; i < PyList_Size(additional); ++i) - { - PyObject *it = PyList_GET_ITEM(additional, i); - if (!PyTuple_Check(it)) - eFatal("poll item is not a tuple"); - if (PyTuple_Size(it) != 2) - eFatal("poll tuple size is not 2"); - int fd = PyObject_AsFileDescriptor(PyTuple_GET_ITEM(it, 0)); - if (fd == -1) - eFatal("poll tuple not a filedescriptor"); - pfd[nativecount + i].fd = fd; - pfd[nativecount + i].events = PyInt_AsLong(PyTuple_GET_ITEM(it, 1)); - } + if (additional) + { + PyObject *key, *val; + int pos=0; + while (PyDict_Next(additional, &pos, &key, &val)) { + pfd[i].fd = PyObject_AsFileDescriptor(key); + pfd[i++].events = PyInt_AsLong(val); } + } + if (this == eApp) + Py_BEGIN_ALLOW_THREADS ret = ::poll(pfd, fdcount, poll_timeout); - + Py_END_ALLOW_THREADS + else + ret = ::poll(pfd, fdcount, poll_timeout); + /* ret > 0 means that there are some active poll entries. */ - if (ret > 0) + if (ret > 0) + { + int i=0; + return_reason = 0; + for (; i < nativecount; ++i) { - return_reason = 0; - for (int i=0; i < nativecount ; i++) + if (pfd[i].revents) { - it = notifiers.begin(); - - int handled = 0; - - std::multimap::iterator - l = notifiers.lower_bound(pfd[i].fd), - u = notifiers.upper_bound(pfd[i].fd); - - ePtrList n; - - for (; l != u; ++l) - n.push_back(l->second); - - for (ePtrList::iterator li(n.begin()); li != n.end(); ++li) + it = notifiers.find(pfd[i].fd); + if (it != notifiers.end() + && it->second->state == 1) // added and in poll { - int req = li->getRequested(); - - handled |= req; - + int req = it->second->getRequested(); if (pfd[i].revents & req) - (*li)->activate(pfd[i].revents); + it->second->activate(pfd[i].revents & req); + pfd[i].revents &= ~req; } - if ((pfd[i].revents&~handled) & (POLLERR|POLLHUP|POLLNVAL)) + if (pfd[i].revents & (POLLERR|POLLHUP|POLLNVAL)) eDebug("poll: unhandled POLLERR/HUP/NVAL for fd %d(%d)", pfd[i].fd, pfd[i].revents); } - - for (int i = nativecount; i < fdcount; ++i) - { - if (pfd[i].revents) - { - if (!*res) - *res = PyList_New(0); - PyObject *it = PyTuple_New(2); - PyTuple_SET_ITEM(it, 0, PyInt_FromLong(pfd[i].fd)); - PyTuple_SET_ITEM(it, 1, PyInt_FromLong(pfd[i].revents)); - PyList_Append(*res, it); - Py_DECREF(it); - } - } - - ret = 1; /* poll did not timeout. */ - } else if (ret < 0) + } + for (; i < fdcount; ++i) { - /* when we got a signal, we get EINTR. */ - if (errno != EINTR) - eDebug("poll made error (%m)"); - else + if (pfd[i].revents) { - return_reason = 2; - ret = -1; /* don't assume the timeout has passed when we got a signal */ + if (!*res) + *res = PyList_New(0); + ePyObject it = PyTuple_New(2); + PyTuple_SET_ITEM(it, 0, PyInt_FromLong(pfd[i].fd)); + PyTuple_SET_ITEM(it, 1, PyInt_FromLong(pfd[i].revents)); + PyList_Append(*res, it); + Py_DECREF(it); } } - delete [] pfd; - Py_XDECREF(additional); } - - /* when we not processed anything, check timers. */ - if (!ret) + else if (ret < 0) { - /* we know that this time has passed. */ - now += poll_timeout; - - singleLock s(recalcLock); - - /* this will never change while we have the recalcLock */ - /* we can savely return here, the timer will be re-checked soon. */ - if (m_now_is_invalid) - return 0; - - /* process all timers which are ready. first remove them out of the list. */ - while ((!m_timer_list.empty()) && (m_timer_list.begin()->getNextActivation() <= now)) - m_timer_list.begin()->activate(); + /* when we got a signal, we get EINTR. */ + if (errno != EINTR) + eDebug("poll made error (%m)"); + else + return_reason = 2; /* don't assume the timeout has passed when we got a signal */ } - + return return_reason; } @@ -307,13 +262,15 @@ void eMainloop::removeTimer(eTimer* e) m_timer_list.remove(e); } -int eMainloop::iterate(unsigned int user_timeout, PyObject **res, PyObject *dict) +int eMainloop::iterate(unsigned int twisted_timeout, PyObject **res, ePyObject dict) { int ret = 0; - - timeval user_timer; - gettimeofday(&user_timer, 0); - user_timer += user_timeout; + + if (twisted_timeout) + { + gettimeofday(&m_twisted_timer, 0); + m_twisted_timer += twisted_timeout; + } /* TODO: this code just became ugly. fix that. */ do @@ -323,23 +280,26 @@ int eMainloop::iterate(unsigned int user_timeout, PyObject **res, PyObject *dict m_interrupt_requested = 0; return 0; } - if (app_quit_now) return -1; - timeval now, timeout; - gettimeofday(&now, 0); - timeout = user_timer - now; - - if (user_timeout && (user_timer <= now)) - return 0; - + + if (app_quit_now) + return -1; + int to = 0; - if (user_timeout) + if (twisted_timeout) + { + timeval now, timeout; + gettimeofday(&now, 0); + m_twisted_timer += time_offset; // apply pending offset + if (m_twisted_timer<=now) // timeout + return 0; + timeout = m_twisted_timer - now; to = timeout.tv_sec * 1000 + timeout.tv_usec / 1000; - + // remove pending offset .. it is re-applied in next call of processOneEvent.. applyTimeOffset + m_twisted_timer -= time_offset; + } ret = processOneEvent(to, res, dict); - if (res && *res) - return ret; - } while (ret == 0); - + } while ( !ret && !(res && *res) ); + return ret; } @@ -350,24 +310,25 @@ int eMainloop::runLoop() return retval; } -PyObject *eMainloop::poll(PyObject *timeout, PyObject *dict) +void eMainloop::reset() +{ + app_quit_now=false; +} + +PyObject *eMainloop::poll(ePyObject timeout, ePyObject dict) { - PyObject *res = 0; - + PyObject *res=0; + if (app_quit_now) - { - Py_INCREF(Py_None); - return Py_None; - } - - int user_timeout = (timeout == Py_None) ? 0 : PyInt_AsLong(timeout); - - iterate(user_timeout, &res, dict); - - if (!res) /* return empty list on timeout */ - res = PyList_New(0); - - return res; + Py_RETURN_NONE; + + int twisted_timeout = (timeout == Py_None) ? 0 : PyInt_AsLong(timeout); + + iterate(twisted_timeout, &res, dict); + if (res) + return res; + + return PyList_New(0); /* return empty list on timeout */ } void eMainloop::interruptPoll() @@ -383,13 +344,33 @@ void eMainloop::quit(int ret) void eMainloop::addTimeOffset(int offset) { - for (ePtrList::iterator it(eMainloop::existing_loops) - ;it != eMainloop::existing_loops.end(); ++it) + for (ePtrList::iterator it(existing_loops.begin()); it != existing_loops.end(); ++it ) + it->addInstanceTimeOffset(offset); +} + +void eMainloop::addInstanceTimeOffset(int offset) +{ + singleLock s(recalcLock); + if (m_timer_list.empty()) + time_offset=0; + else + { + if ( time_offset ) + eDebug("time_offset %d avail.. add new offset %d than new is %d", + time_offset, offset, time_offset+offset); + time_offset+=offset; + } +} + +void eMainloop::applyTimeOffset() +{ + singleLock s(recalcLock); + if ( time_offset ) { - singleLock s(it->recalcLock); - it->m_now_is_invalid = 1; - for (ePtrList::iterator tit = it->m_timer_list.begin(); tit != it->m_timer_list.end(); ++tit ) - tit->addTimeOffset(offset); + for (ePtrList::iterator it(m_timer_list.begin()); it != m_timer_list.end(); ++it ) + it->addTimeOffset( time_offset ); + m_twisted_timer += time_offset; + time_offset=0; } }