X-Git-Url: http://g0dil.de/git?a=blobdiff_plain;f=senf%2FScheduler%2FFIFORunner.cc;h=7253ffc20b09538089ed6369b585f4fb351e2edb;hb=ab7ff164ab5ae711ec09ce2b24228510f1ffdcff;hp=9908e91d176fefa2365f17ccaaf0f246e74f855d;hpb=b9bc7df8121501f84f5a48e854ebaa4984a44932;p=senf.git diff --git a/senf/Scheduler/FIFORunner.cc b/senf/Scheduler/FIFORunner.cc index 9908e91..7253ffc 100644 --- a/senf/Scheduler/FIFORunner.cc +++ b/senf/Scheduler/FIFORunner.cc @@ -2,23 +2,28 @@ // // Copyright (C) 2008 // Fraunhofer Institute for Open Communication Systems (FOKUS) -// Competence Center NETwork research (NET), St. Augustin, GERMANY -// Stefan Bund // -// This program is free software; you can redistribute it and/or modify -// it under the terms of the GNU General Public License as published by -// the Free Software Foundation; either version 2 of the License, or -// (at your option) any later version. +// The contents of this file are subject to the Fraunhofer FOKUS Public License +// Version 1.0 (the "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// http://senf.berlios.de/license.html // -// This program is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. +// The Fraunhofer FOKUS Public License Version 1.0 is based on, +// but modifies the Mozilla Public License Version 1.1. +// See the full license text for the amendments. // -// You should have received a copy of the GNU General Public License -// along with this program; if not, write to the -// Free Software Foundation, Inc., -// 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// Software distributed under the License is distributed on an "AS IS" basis, +// WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License +// for the specific language governing rights and limitations under the License. +// +// The Original Code is Fraunhofer FOKUS code. +// +// The Initial Developer of the Original Code is Fraunhofer-Gesellschaft e.V. +// (registered association), Hansastraße 27 c, 80686 Munich, Germany. +// All Rights Reserved. +// +// Contributor(s): +// Stefan Bund /** \file \brief FIFORunner non-inline non-template implementation */ @@ -29,21 +34,22 @@ // Custom includes #include #include -#include -#include -#include -#include -#ifdef SENF_DEBUG - #include -#endif +#include #include +#ifdef SENF_BACKTRACE + #include +#endif #include #include +#include #include "senf/Utils/IgnoreValue.hh" +#include +#include +#include "ConsoleDir.hh" //#include "FIFORunner.mpp" #define prefix_ -///////////////////////////////cc.p//////////////////////////////////////// +//-///////////////////////////////////////////////////////////////////////////////////////////////// prefix_ senf::scheduler::detail::FIFORunner::FIFORunner() : tasks_ (), next_ (tasks_.end()), watchdogRunning_ (false), watchdogMs_ (1000), @@ -72,12 +78,38 @@ prefix_ senf::scheduler::detail::FIFORunner::FIFORunner() tasks_.push_back(highPriorityEnd_); tasks_.push_back(normalPriorityEnd_); + +#ifndef SENF_DISABLE_CONSOLE + namespace fty = console::factory; + consoleDir().add("abortOnWatchdocTimeout", fty::Command( + SENF_MEMBINDFNP( bool, FIFORunner, abortOnTimeout, () const )) + .doc("Get current watchdog abort on event status.") ); + consoleDir().add("abortOnWatchdocTimeout", fty::Command( + SENF_MEMBINDFNP( void, FIFORunner, abortOnTimeout, (bool) )) + .doc("Enable/disable abort on watchdog event.") ); + consoleDir().add("watchdogTimeout", fty::Command( + SENF_MEMBINDFNP( unsigned, FIFORunner, taskTimeout, () const )) + .doc("Get current watchdog timeout in milliseconds") ); + consoleDir().add("watchdogTimeout", fty::Command( + SENF_MEMBINDFNP( void, FIFORunner, taskTimeout, (unsigned) )) + .doc("Set watchdog timeout to in milliseconds\n" + "Setting the watchdog timeout to 0 will disable the watchdog.") ); + consoleDir().add("watchdogEvents", fty::Command(membind( &FIFORunner::hangCount, this)) + .doc("Get number of occurred watchdog events.\n" + "Calling this method will reset the counter to 0") ); +#endif } prefix_ senf::scheduler::detail::FIFORunner::~FIFORunner() { timer_delete(watchdogId_); signal(SIGURG, SIG_DFL); + +#ifndef SENF_DISABLE_CONSOLE + consoleDir().remove("abortOnWatchdocTimeout"); + consoleDir().remove("watchdogTimeout"); + consoleDir().remove("watchdogEvents"); +#endif } prefix_ void senf::scheduler::detail::FIFORunner::startWatchdog() @@ -114,7 +146,7 @@ prefix_ void senf::scheduler::detail::FIFORunner::stopWatchdog() // At the moment, the FIFORunner is not very efficient with many non-runnable tasks since the // complete list of tasks is traversed on each run(). // -// To optimize this, we woould need a way to find the relative ordering of two tasks in O(1) (at the +// To optimize this, we would need a way to find the relative ordering of two tasks in O(1) (at the // moment, this is an O(N) operation by traversing the list). // // One idea is, to give each task an 'order' value. Whenever a task is added at the end, it's order @@ -143,7 +175,7 @@ prefix_ void senf::scheduler::detail::FIFORunner::dequeue(TaskInfo * task) prefix_ void senf::scheduler::detail::FIFORunner::run() { - for(;;) { + for (;;) { TaskList::iterator f (tasks_.begin()); TaskList::iterator l (TaskList::current(highPriorityEnd_)); run(f, l); @@ -192,31 +224,37 @@ prefix_ void senf::scheduler::detail::FIFORunner::run(TaskList::iterator f, Task TaskList::iterator end (TaskList::current(null)); next_ = f; - using namespace boost::lambda; - ScopeExit atExit (( - var(watchdogCount_) = 0, - var(next_) = l - )); - - while (next_ != end) { - TaskInfo & task (*next_); - if (task.runnable_) { - task.runnable_ = false; - runningName_ = task.name(); -# ifdef SENF_DEBUG - runningBacktrace_ = task.backtrace_; -# endif - TaskList::iterator i (next_); - ++ next_; - tasks_.splice(l, tasks_, i); - watchdogCount_ = 1; - yield_ = false; - task.run(); - if (yield_) - return; + // Would prefer to use ScopeExit+boost::lambda here instead of try but profiling has shown that + // to be to costly here + + try { + while (next_ != end) { + TaskInfo & task (*next_); + if (task.runnable_) { + task.runnable_ = false; + runningName_ = task.name(); +# ifdef SENF_BACKTRACE + runningBacktrace_ = task.backtrace_; +# endif + TaskList::iterator i (next_); + ++ next_; + tasks_.splice(l, tasks_, i); + watchdogCount_ = 1; + yield_ = false; + task.run(); + if (yield_) + return; + } + else + ++ next_; } - else - ++ next_; + watchdogCount_ = 0; + next_ = l; + } + catch (...) { + watchdogCount_ = 0; + next_ = l; + throw; } } @@ -224,11 +262,11 @@ prefix_ senf::scheduler::detail::FIFORunner::TaskList::iterator senf::scheduler::detail::FIFORunner::priorityEnd(TaskInfo::Priority p) { switch (p) { - case senf::scheduler::detail::FIFORunner::TaskInfo::PRIORITY_LOW : + case TaskInfo::PRIORITY_LOW : return tasks_.end(); - case senf::scheduler::detail::FIFORunner::TaskInfo::PRIORITY_NORMAL : + case TaskInfo::PRIORITY_NORMAL : return TaskList::current(normalPriorityEnd_); - case senf::scheduler::detail::FIFORunner::TaskInfo::PRIORITY_HIGH : + case TaskInfo::PRIORITY_HIGH : return TaskList::current(highPriorityEnd_); } return tasks_.begin(); @@ -248,10 +286,6 @@ prefix_ void senf::scheduler::detail::FIFORunner::watchdog(int, siginfo_t * si, prefix_ void senf::scheduler::detail::FIFORunner::watchdogError() { - static char const hex[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', - 'a', 'b', 'c', 'd', 'e', 'f' }; - static void * entries[SENF_DEBUG_BACKTRACE_NUMCALLERS]; - // We don't care if the write commands below fail, we just give our best to inform the user senf::IGNORE( write(1, "\n\n*** Scheduler task hanging (pid ",34) ); static char pid[7]; @@ -260,10 +294,13 @@ prefix_ void senf::scheduler::detail::FIFORunner::watchdogError() senf::IGNORE( write(1, pid, 6) ); senf::IGNORE( write(1, "): ", 3) ); senf::IGNORE( write(1, runningName_.c_str(), runningName_.size()) ); - senf::IGNORE( write(1, " at\n ", 3) ); -#ifdef SENF_DEBUG - unsigned nEntries( ::backtrace(entries, SENF_DEBUG_BACKTRACE_NUMCALLERS) ); - for (unsigned i (0); i < nEntries; ++i) { +/* senf::IGNORE( write(1, " at\n ", 3) ); +#ifdef SENF_BACKTRACE + static char const hex[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', + 'a', 'b', 'c', 'd', 'e', 'f' }; + static void * entries[SENF_DEBUG_BACKTRACE_NUMCALLERS]; + int nEntries( ::backtrace(entries, SENF_DEBUG_BACKTRACE_NUMCALLERS) ); + for (int i=0; i < nEntries; ++i) { senf::IGNORE( write(1, " 0x", 3) ); for (unsigned j (sizeof(void*)); j > 0; --j) { uintptr_t v ( reinterpret_cast(entries[i]) >> (8*(j-1)) ); @@ -271,10 +308,10 @@ prefix_ void senf::scheduler::detail::FIFORunner::watchdogError() senf::IGNORE( write(1, &(hex[ (v ) & 0x0f ]), 1) ); } } -#endif +#endif*/ senf::IGNORE( write(1, "\n", 1) ); -#ifdef SENF_DEBUG +#ifdef SENF_BACKTRACE senf::IGNORE( write(1, "Task was initialized at\n", 24) ); senf::IGNORE( write(1, runningBacktrace_.c_str(), runningBacktrace_.size()) ); #endif @@ -283,7 +320,7 @@ prefix_ void senf::scheduler::detail::FIFORunner::watchdogError() assert(false); } -///////////////////////////////cc.e//////////////////////////////////////// +//-///////////////////////////////////////////////////////////////////////////////////////////////// #undef prefix_ //#include "FIFORunner.mpp"