[PATCH 8/8] score: Replace watchdog handler implementation
Joel Sherrill
joel at rtems.org
Thu Mar 3 15:23:24 UTC 2016
This looks OK but is such a large patch, it needs more eyes.
Gedare and Chris... please.
On Thu, Mar 3, 2016 at 8:47 AM, Sebastian Huber <
sebastian.huber at embedded-brains.de> wrote:
> Use a red-black tree instead of delta chains.
>
> Close #2344.
> Update #2554.
> Update #2555.
> Close #2606.
> ---
> cpukit/posix/Makefile.am | 3 +-
> cpukit/posix/include/rtems/posix/pthreadimpl.h | 5 +-
> cpukit/posix/include/rtems/posix/threadsup.h | 2 +
> cpukit/posix/include/rtems/posix/timerimpl.h | 54 +-
> cpukit/posix/src/alarm.c | 96 ++--
> cpukit/posix/src/nanosleep.c | 5 +-
> cpukit/posix/src/pthread.c | 31 +-
> cpukit/posix/src/pthreadcreate.c | 6 +-
> cpukit/posix/src/pthreadsetschedparam.c | 14 +-
> cpukit/posix/src/timercreate.c | 3 +-
> cpukit/posix/src/timerdelete.c | 12 +-
> cpukit/posix/src/timergetoverrun.c | 7 +-
> cpukit/posix/src/timergettime.c | 29 +-
> cpukit/posix/src/timerinserthelper.c | 66 ---
> cpukit/posix/src/timersettime.c | 152 ++++--
> cpukit/posix/src/timertsr.c | 89 ----
> cpukit/posix/src/ualarm.c | 155 +++---
> cpukit/rtems/include/rtems/rtems/ratemonimpl.h | 24 +-
> cpukit/rtems/include/rtems/rtems/timer.h | 59 ++-
> cpukit/rtems/include/rtems/rtems/timerimpl.h | 216 ++++----
> cpukit/rtems/src/eventseize.c | 11 +-
> cpukit/rtems/src/eventsurrender.c | 2 +-
> cpukit/rtems/src/ratemoncancel.c | 5 +-
> cpukit/rtems/src/ratemoncreate.c | 3 +-
> cpukit/rtems/src/ratemondelete.c | 5 +-
> cpukit/rtems/src/ratemonperiod.c | 38 +-
> cpukit/rtems/src/ratemontimeout.c | 50 +-
> cpukit/rtems/src/taskwakeafter.c | 9 +-
> cpukit/rtems/src/taskwakewhen.c | 18 +-
> cpukit/rtems/src/timercancel.c | 31 +-
> cpukit/rtems/src/timercreate.c | 179 ++++++-
> cpukit/rtems/src/timerdelete.c | 14 +-
> cpukit/rtems/src/timerfireafter.c | 64 +--
> cpukit/rtems/src/timerfirewhen.c | 50 +-
> cpukit/rtems/src/timergetinfo.c | 13 +-
> cpukit/rtems/src/timerreset.c | 41 +-
> cpukit/rtems/src/timerserver.c | 394 ++++----------
> cpukit/rtems/src/timerserverfireafter.c | 68 +--
> cpukit/rtems/src/timerserverfirewhen.c | 70 +--
> cpukit/sapi/src/exinit.c | 3 -
> cpukit/score/Makefile.am | 5 +-
> cpukit/score/include/rtems/score/mrsp.h | 7 +-
> cpukit/score/include/rtems/score/mrspimpl.h | 32 +-
> cpukit/score/include/rtems/score/percpu.h | 53 +-
> cpukit/score/include/rtems/score/schedulerimpl.h | 16 +-
> cpukit/score/include/rtems/score/thread.h | 13 +-
> cpukit/score/include/rtems/score/threadimpl.h | 61 ++-
> cpukit/score/include/rtems/score/todimpl.h | 17 -
> cpukit/score/include/rtems/score/watchdog.h | 89 ++--
> cpukit/score/include/rtems/score/watchdogimpl.h | 590
> +++++++++------------
> cpukit/score/src/condition.c | 2 +-
> cpukit/score/src/coretodset.c | 28 +-
> cpukit/score/src/coretodtickle.c | 36 --
> cpukit/score/src/kern_tc.c | 3 +-
> cpukit/score/src/smp.c | 1 +
> cpukit/score/src/threadinitialize.c | 4 +
> cpukit/score/src/threadqenqueue.c | 10 +-
> cpukit/score/src/threadrestart.c | 12 +-
> cpukit/score/src/threadtimeout.c | 4 +-
> cpukit/score/src/watchdog.c | 36 --
> cpukit/score/src/watchdogadjust.c | 80 ---
> cpukit/score/src/watchdoginsert.c | 132 ++---
> cpukit/score/src/watchdogremove.c | 172 +-----
> cpukit/score/src/watchdogtick.c | 78 ++-
> testsuites/smptests/Makefile.am | 1 +
> testsuites/smptests/configure.ac | 1 +
> testsuites/smptests/smpclock01/Makefile.am | 20 +
> testsuites/smptests/smpclock01/init.c | 206 +++++++
> testsuites/smptests/smpclock01/smpclock01.doc | 11 +
> testsuites/smptests/smpclock01/smpclock01.scn | 2 +
> .../smptests/smpwakeafter01/smpwakeafter01.scn | 224 ++++++--
> testsuites/sptests/Makefile.am | 3 +-
> testsuites/sptests/configure.ac | 2 +-
> testsuites/sptests/sp31/task1.c | 22 -
> testsuites/sptests/spintrcritical08/init.c | 26 +-
> testsuites/sptests/spintrcritical09/init.c | 27 +-
> testsuites/sptests/spintrcritical10/init.c | 6 +-
> testsuites/sptests/spintrcritical16/init.c | 2 +-
> testsuites/sptests/spintrcritical17/Makefile.am | 25 -
> testsuites/sptests/spintrcritical17/init.c | 118 -----
> .../sptests/spintrcritical17/spintrcritical17.doc | 18 -
> .../sptests/spintrcritical17/spintrcritical17.scn | 2 -
> testsuites/sptests/spintrcritical20/init.c | 2 +-
> testsuites/sptests/spsize/size.c | 2 -
> testsuites/sptests/sptimecounter01/init.c | 3 -
> testsuites/sptests/sptimerserver01/Makefile.am | 19 +
> testsuites/sptests/sptimerserver01/init.c | 129 +++++
> .../sptests/sptimerserver01/sptimerserver01.doc | 12 +
> .../sptests/sptimerserver01/sptimerserver01.scn | 2 +
> testsuites/sptests/spwatchdog/init.c | 381 ++++++-------
> testsuites/tmtests/tmtimer01/tmtimer01.scn | 90 ++--
> 91 files changed, 2340 insertions(+), 2593 deletions(-)
> delete mode 100644 cpukit/posix/src/timerinserthelper.c
> delete mode 100644 cpukit/posix/src/timertsr.c
> delete mode 100644 cpukit/score/src/coretodtickle.c
> delete mode 100644 cpukit/score/src/watchdog.c
> delete mode 100644 cpukit/score/src/watchdogadjust.c
> create mode 100644 testsuites/smptests/smpclock01/Makefile.am
> create mode 100644 testsuites/smptests/smpclock01/init.c
> create mode 100644 testsuites/smptests/smpclock01/smpclock01.doc
> create mode 100644 testsuites/smptests/smpclock01/smpclock01.scn
> delete mode 100644 testsuites/sptests/spintrcritical17/Makefile.am
> delete mode 100644 testsuites/sptests/spintrcritical17/init.c
> delete mode 100644
> testsuites/sptests/spintrcritical17/spintrcritical17.doc
> delete mode 100644
> testsuites/sptests/spintrcritical17/spintrcritical17.scn
> create mode 100644 testsuites/sptests/sptimerserver01/Makefile.am
> create mode 100644 testsuites/sptests/sptimerserver01/init.c
> create mode 100644 testsuites/sptests/sptimerserver01/sptimerserver01.doc
> create mode 100644 testsuites/sptests/sptimerserver01/sptimerserver01.scn
>
> diff --git a/cpukit/posix/Makefile.am b/cpukit/posix/Makefile.am
> index 40bc153..62a2a5a 100644
> --- a/cpukit/posix/Makefile.am
> +++ b/cpukit/posix/Makefile.am
> @@ -196,8 +196,7 @@ libposix_a_SOURCES += src/adjtime.c
> src/clockgetcpuclockid.c
>
> ## TIMER_C_FILES
> libposix_a_SOURCES += src/ptimer.c src/timercreate.c src/timerdelete.c \
> - src/timergetoverrun.c src/timergettime.c src/timersettime.c \
> - src/timertsr.c src/timerinserthelper.c
> + src/timergetoverrun.c src/timergettime.c src/timersettime.c
>
> ## ITIMER_C_FILES
> libposix_a_SOURCES += src/getitimer.c src/setitimer.c
> diff --git a/cpukit/posix/include/rtems/posix/pthreadimpl.h
> b/cpukit/posix/include/rtems/posix/pthreadimpl.h
> index 870b5f9..16b0163 100644
> --- a/cpukit/posix/include/rtems/posix/pthreadimpl.h
> +++ b/cpukit/posix/include/rtems/posix/pthreadimpl.h
> @@ -114,10 +114,7 @@ void _POSIX_Threads_Sporadic_budget_callout(
> * @param[in] argument is a pointer to the Thread_Control structure
> * for the thread being replenished.
> */
> -void _POSIX_Threads_Sporadic_budget_TSR(
> - Objects_Id id,
> - void *argument
> -);
> +void _POSIX_Threads_Sporadic_budget_TSR( Watchdog_Control *watchdog );
>
> /**
> * @brief Translate sched_param into SuperCore terms.
> diff --git a/cpukit/posix/include/rtems/posix/threadsup.h
> b/cpukit/posix/include/rtems/posix/threadsup.h
> index 55db35d..7cd2354 100644
> --- a/cpukit/posix/include/rtems/posix/threadsup.h
> +++ b/cpukit/posix/include/rtems/posix/threadsup.h
> @@ -42,6 +42,8 @@ extern "C" {
> * each thread in a system with POSIX configured.
> */
> typedef struct {
> + /** Back pointer to thread of this POSIX API control. */
> + Thread_Control *thread;
> /** This is the POSIX threads attribute set. */
> pthread_attr_t Attributes;
> /** This indicates whether the thread is attached or detached. */
> diff --git a/cpukit/posix/include/rtems/posix/timerimpl.h
> b/cpukit/posix/include/rtems/posix/timerimpl.h
> index 8b5b42e..8c151c1 100644
> --- a/cpukit/posix/include/rtems/posix/timerimpl.h
> +++ b/cpukit/posix/include/rtems/posix/timerimpl.h
> @@ -21,6 +21,7 @@
>
> #include <rtems/posix/timer.h>
> #include <rtems/score/objectimpl.h>
> +#include <rtems/score/watchdogimpl.h>
>
> #ifdef __cplusplus
> extern "C" {
> @@ -51,24 +52,6 @@ extern "C" {
> #endif
>
> /**
> - * @brief POSIX Timer Manager Timer Service Routine Helper
> - *
> - * This is the operation that is run when a timer expires.
> - */
> -void _POSIX_Timer_TSR(Objects_Id timer, void *data);
> -
> -/**
> - * @brief POSIX Timer Watchdog Insertion Helper
> - */
> -bool _POSIX_Timer_Insert_helper(
> - Watchdog_Control *timer,
> - Watchdog_Interval ticks,
> - Objects_Id id,
> - Watchdog_Service_routine_entry TSR,
> - void *arg
> -);
> -
> -/**
> * The following defines the information control block used to manage
> * this class of objects.
> */
> @@ -98,6 +81,8 @@ RTEMS_INLINE_ROUTINE void _POSIX_Timer_Free (
> _Objects_Free( &_POSIX_Timer_Information, &the_timer->Object );
> }
>
> +void _POSIX_Timer_TSR( Watchdog_Control *the_watchdog );
> +
> /**
> * @brief POSIX Timer Get
> *
> @@ -109,11 +94,38 @@ RTEMS_INLINE_ROUTINE void _POSIX_Timer_Free (
> */
> RTEMS_INLINE_ROUTINE POSIX_Timer_Control *_POSIX_Timer_Get (
> timer_t id,
> - Objects_Locations *location
> + Objects_Locations *location,
> + ISR_lock_Context *lock_context
> +)
> +{
> + return (POSIX_Timer_Control *) _Objects_Get_isr_disable(
> + &_POSIX_Timer_Information,
> + (Objects_Id) id,
> + location,
> + lock_context
> + );
> +}
> +
> +RTEMS_INLINE_ROUTINE Per_CPU_Control *_POSIX_Timer_Acquire_critical(
> + POSIX_Timer_Control *ptimer,
> + ISR_lock_Context *lock_context
> +)
> +{
> + Per_CPU_Control *cpu;
> +
> + cpu = _Watchdog_Get_CPU( &ptimer->Timer );
> + _Watchdog_Per_CPU_acquire( cpu, lock_context );
> +
> + return cpu;
> +}
> +
> +RTEMS_INLINE_ROUTINE void _POSIX_Timer_Release(
> + Per_CPU_Control *cpu,
> + ISR_lock_Context *lock_context
> )
> {
> - return (POSIX_Timer_Control *)
> - _Objects_Get( &_POSIX_Timer_Information, (Objects_Id) id, location );
> + _Watchdog_Per_CPU_release( cpu, lock_context );
> + _ISR_lock_ISR_enable( lock_context );
> }
>
> #ifdef __cplusplus
> diff --git a/cpukit/posix/src/alarm.c b/cpukit/posix/src/alarm.c
> index e85622f..196bc16 100644
> --- a/cpukit/posix/src/alarm.c
> +++ b/cpukit/posix/src/alarm.c
> @@ -22,29 +22,18 @@
> #endif
>
> #include <unistd.h>
> +#include <signal.h>
>
> -#include <rtems/posix/pthreadimpl.h>
> -#include <rtems/posix/psignalimpl.h>
> -#include <rtems/score/threaddispatch.h>
> #include <rtems/score/todimpl.h>
> #include <rtems/score/watchdogimpl.h>
>
> -/*
> - * _POSIX_signals_Alarm_TSR
> - */
> -static void _POSIX_signals_Alarm_TSR(
> - Objects_Id id RTEMS_UNUSED,
> - void *argument RTEMS_UNUSED
> -)
> +ISR_LOCK_DEFINE( static, _POSIX_signals_Alarm_lock, "POSIX Alarm" )
> +
> +static void _POSIX_signals_Alarm_TSR( Watchdog_Control *the_watchdog )
> {
> - #if defined(RTEMS_DEBUG)
> - int status;
> - #define KILL_STATUS status =
> - #else
> - #define KILL_STATUS (void)
> - #endif
> + int status;
>
> - KILL_STATUS kill( getpid(), SIGALRM );
> + status = kill( getpid(), SIGALRM );
>
> #if defined(RTEMS_DEBUG)
> /*
> @@ -52,43 +41,62 @@ static void _POSIX_signals_Alarm_TSR(
> * cautious.
> */
> _Assert(status == 0);
> + #else
> + (void) status;
> #endif
> }
>
> -static Watchdog_Control _POSIX_signals_Alarm_timer = WATCHDOG_INITIALIZER(
> - _POSIX_signals_Alarm_TSR,
> - 0,
> - NULL
> +static Watchdog_Control _POSIX_signals_Alarm_watchdog =
> WATCHDOG_INITIALIZER(
> + _POSIX_signals_Alarm_TSR
> );
>
> unsigned int alarm(
> unsigned int seconds
> )
> {
> - unsigned int remaining = 0;
> - Watchdog_Control *the_timer;
> - Watchdog_States state;
> -
> - the_timer = &_POSIX_signals_Alarm_timer;
> -
> - _Thread_Disable_dispatch();
> -
> - state = _Watchdog_Remove_seconds( the_timer );
> - if ( state == WATCHDOG_ACTIVE ) {
> - /*
> - * The stop_time and start_time fields are snapshots of ticks since
> - * boot. Since alarm() is dealing in seconds, we must account for
> - * this.
> - */
> -
> - remaining = the_timer->initial -
> - ((the_timer->stop_time - the_timer->start_time) /
> TOD_TICKS_PER_SECOND);
> + unsigned int remaining;
> + Watchdog_Control *the_watchdog;
> + ISR_lock_Context lock_context;
> + ISR_lock_Context lock_context2;
> + Per_CPU_Control *cpu;
> + uint64_t now;
> + uint32_t ticks_per_second;
> + uint32_t ticks;
> +
> + the_watchdog = &_POSIX_signals_Alarm_watchdog;
> + ticks_per_second = TOD_TICKS_PER_SECOND;
> + ticks = seconds * ticks_per_second;
> +
> + _ISR_lock_ISR_disable_and_acquire(
> + &_POSIX_signals_Alarm_lock,
> + &lock_context
> + );
> +
> + cpu = _Watchdog_Get_CPU( the_watchdog );
> + _Watchdog_Per_CPU_acquire( cpu, &lock_context2 );
> + now = cpu->Watchdog.ticks;
> +
> + remaining = (unsigned long) _Watchdog_Cancel(
> + &cpu->Watchdog.Header[ PER_CPU_WATCHDOG_RELATIVE ],
> + the_watchdog,
> + now
> + );
> +
> + if ( ticks != 0 ) {
> + cpu = _Per_CPU_Get();
> + _Watchdog_Set_CPU( the_watchdog, cpu );
> + _Watchdog_Insert(
> + &cpu->Watchdog.Header[ PER_CPU_WATCHDOG_RELATIVE ],
> + the_watchdog,
> + now + ticks
> + );
> }
>
> - if ( seconds )
> - _Watchdog_Insert_seconds( the_timer, seconds );
> -
> - _Thread_Enable_dispatch();
> + _Watchdog_Per_CPU_release( cpu, &lock_context2 );
> + _ISR_lock_Release_and_ISR_enable(
> + &_POSIX_signals_Alarm_lock,
> + &lock_context
> + );
>
> - return remaining;
> + return ( remaining + ticks_per_second - 1 ) / ticks_per_second;
> }
> diff --git a/cpukit/posix/src/nanosleep.c b/cpukit/posix/src/nanosleep.c
> index 46697ae..21bdb98 100644
> --- a/cpukit/posix/src/nanosleep.c
> +++ b/cpukit/posix/src/nanosleep.c
> @@ -46,6 +46,7 @@ int nanosleep(
> Per_CPU_Control *cpu_self;
>
> Watchdog_Interval ticks;
> + Watchdog_Interval start;
> Watchdog_Interval elapsed;
>
>
> @@ -81,6 +82,8 @@ int nanosleep(
> return 0;
> }
>
> + start = _Watchdog_Ticks_since_boot;
> +
> /*
> * Block for the desired amount of time
> */
> @@ -96,7 +99,7 @@ int nanosleep(
> * Calculate the time that passed while we were sleeping and how
> * much remains from what we requested.
> */
> - elapsed = executing->Timer.stop_time - executing->Timer.start_time;
> + elapsed = _Watchdog_Ticks_since_boot - start;
> if ( elapsed >= ticks )
> ticks = 0;
> else
> diff --git a/cpukit/posix/src/pthread.c b/cpukit/posix/src/pthread.c
> index ac5fbe4..001ae79 100644
> --- a/cpukit/posix/src/pthread.c
> +++ b/cpukit/posix/src/pthread.c
> @@ -104,18 +104,15 @@ static bool
> _POSIX_Threads_Sporadic_budget_TSR_filter(
> /*
> * _POSIX_Threads_Sporadic_budget_TSR
> */
> -void _POSIX_Threads_Sporadic_budget_TSR(
> - Objects_Id id RTEMS_UNUSED,
> - void *argument
> -)
> +void _POSIX_Threads_Sporadic_budget_TSR( Watchdog_Control *watchdog )
> {
> uint32_t ticks;
> - Thread_Control *the_thread;
> POSIX_API_Control *api;
> + Thread_Control *the_thread;
> + ISR_Level level;
>
> - the_thread = argument;
> -
> - api = the_thread->API_Extensions[ THREAD_API_POSIX ];
> + api = RTEMS_CONTAINER_OF( watchdog, POSIX_API_Control, Sporadic_timer );
> + the_thread = api->thread;
>
> /* ticks is guaranteed to be at least one */
> ticks = _Timespec_To_ticks( &api->schedparam.sched_ss_init_budget );
> @@ -133,7 +130,15 @@ void _POSIX_Threads_Sporadic_budget_TSR(
> /* ticks is guaranteed to be at least one */
> ticks = _Timespec_To_ticks( &api->schedparam.sched_ss_repl_period );
>
> - _Watchdog_Insert_ticks( &api->Sporadic_timer, ticks );
> + _Thread_Disable_dispatch();
> + _ISR_Disable( level );
> + _Watchdog_Per_CPU_insert_relative(
> + &api->Sporadic_timer,
> + _Per_CPU_Get(),
> + ticks
> + );
> + _ISR_Enable( level );
> + _Thread_Unnest_dispatch();
> }
>
> static bool _POSIX_Threads_Sporadic_budget_callout_filter(
> @@ -198,6 +203,7 @@ static bool _POSIX_Threads_Create_extension(
> api = created->API_Extensions[ THREAD_API_POSIX ];
>
> /* XXX check all fields are touched */
> + api->thread = created;
> _POSIX_Threads_Initialize_attributes( &api->Attributes );
> api->detachstate = _POSIX_Threads_Default_attributes.detachstate;
> api->schedpolicy = _POSIX_Threads_Default_attributes.schedpolicy;
> @@ -229,11 +235,10 @@ static bool _POSIX_Threads_Create_extension(
>
> _Thread_queue_Initialize( &api->Join_List, THREAD_QUEUE_DISCIPLINE_FIFO
> );
>
> + _Watchdog_Preinitialize( &api->Sporadic_timer, _Per_CPU_Get_by_index( 0
> ) );
> _Watchdog_Initialize(
> &api->Sporadic_timer,
> - _POSIX_Threads_Sporadic_budget_TSR,
> - created->Object.id,
> - created
> + _POSIX_Threads_Sporadic_budget_TSR
> );
>
> return true;
> @@ -260,7 +265,7 @@ static void _POSIX_Threads_Terminate_extension(
> *(void **)the_thread->Wait.return_argument = value_ptr;
>
> if ( api->schedpolicy == SCHED_SPORADIC )
> - _Watchdog_Remove_ticks( &api->Sporadic_timer );
> + _Watchdog_Per_CPU_remove_relative( &api->Sporadic_timer );
>
> _Thread_queue_Destroy( &api->Join_List );
>
> diff --git a/cpukit/posix/src/pthreadcreate.c
> b/cpukit/posix/src/pthreadcreate.c
> index 3185ab6..fc07b1f 100644
> --- a/cpukit/posix/src/pthreadcreate.c
> +++ b/cpukit/posix/src/pthreadcreate.c
> @@ -74,6 +74,7 @@ int pthread_create(
> struct sched_param schedparam;
> Objects_Name name;
> int rc;
> + ISR_Level level;
>
> if ( !start_routine )
> return EFAULT;
> @@ -246,10 +247,13 @@ int pthread_create(
> #endif
>
> if ( schedpolicy == SCHED_SPORADIC ) {
> - _Watchdog_Insert_ticks(
> + _ISR_Disable( level );
> + _Watchdog_Per_CPU_insert_relative(
> &api->Sporadic_timer,
> + _Per_CPU_Get(),
> _Timespec_To_ticks( &api->schedparam.sched_ss_repl_period )
> );
> + _ISR_Enable( level );
> }
>
> _Thread_Enable_dispatch();
> diff --git a/cpukit/posix/src/pthreadsetschedparam.c
> b/cpukit/posix/src/pthreadsetschedparam.c
> index c3be366..c9560f5 100644
> --- a/cpukit/posix/src/pthreadsetschedparam.c
> +++ b/cpukit/posix/src/pthreadsetschedparam.c
> @@ -44,6 +44,7 @@ int pthread_setschedparam(
> Objects_Locations location;
> int rc;
> Priority_Control unused;
> + ISR_Level level;
>
> /*
> * Check all the parameters
> @@ -69,8 +70,11 @@ int pthread_setschedparam(
> case OBJECTS_LOCAL:
> api = the_thread->API_Extensions[ THREAD_API_POSIX ];
>
> - if ( api->schedpolicy == SCHED_SPORADIC )
> - _Watchdog_Remove_ticks( &api->Sporadic_timer );
> + if ( api->schedpolicy == SCHED_SPORADIC ) {
> + _ISR_Disable( level );
> + _Watchdog_Per_CPU_remove_relative( &api->Sporadic_timer );
> + _ISR_Enable( level );
> + }
>
> api->schedpolicy = policy;
> api->schedparam = *param;
> @@ -97,8 +101,10 @@ int pthread_setschedparam(
>
> case SCHED_SPORADIC:
> api->ss_high_priority = api->schedparam.sched_priority;
> - _Watchdog_Remove_ticks( &api->Sporadic_timer );
> - _POSIX_Threads_Sporadic_budget_TSR( 0, the_thread );
> + _ISR_Disable( level );
> + _Watchdog_Per_CPU_remove_relative( &api->Sporadic_timer );
> + _ISR_Enable( level );
> + _POSIX_Threads_Sporadic_budget_TSR( &api->Sporadic_timer );
> break;
> }
>
> diff --git a/cpukit/posix/src/timercreate.c
> b/cpukit/posix/src/timercreate.c
> index 697f1ce..5123071 100644
> --- a/cpukit/posix/src/timercreate.c
> +++ b/cpukit/posix/src/timercreate.c
> @@ -91,7 +91,8 @@ int timer_create(
> ptimer->timer_data.it_interval.tv_sec = 0;
> ptimer->timer_data.it_interval.tv_nsec = 0;
>
> - _Watchdog_Preinitialize( &ptimer->Timer );
> + _Watchdog_Preinitialize( &ptimer->Timer, _Per_CPU_Get_snapshot() );
> + _Watchdog_Initialize( &ptimer->Timer, _POSIX_Timer_TSR );
> _Objects_Open_u32(&_POSIX_Timer_Information, &ptimer->Object, 0);
>
> *timerid = ptimer->Object.id;
> diff --git a/cpukit/posix/src/timerdelete.c
> b/cpukit/posix/src/timerdelete.c
> index 8438b0d..c39de8e 100644
> --- a/cpukit/posix/src/timerdelete.c
> +++ b/cpukit/posix/src/timerdelete.c
> @@ -45,16 +45,22 @@ int timer_delete(
> */
> POSIX_Timer_Control *ptimer;
> Objects_Locations location;
> + ISR_lock_Context lock_context;
> + Per_CPU_Control *cpu;
>
> _Objects_Allocator_lock();
> - ptimer = _POSIX_Timer_Get( timerid, &location );
> + ptimer = _POSIX_Timer_Get( timerid, &location, &lock_context );
> switch ( location ) {
>
> case OBJECTS_LOCAL:
> _Objects_Close( &_POSIX_Timer_Information, &ptimer->Object );
> + cpu = _POSIX_Timer_Acquire_critical( ptimer, &lock_context );
> ptimer->state = POSIX_TIMER_STATE_FREE;
> - _Watchdog_Remove_ticks( &ptimer->Timer );
> - _Objects_Put( &ptimer->Object );
> + _Watchdog_Remove(
> + &cpu->Watchdog.Header[ PER_CPU_WATCHDOG_RELATIVE ],
> + &ptimer->Timer
> + );
> + _POSIX_Timer_Release( cpu, &lock_context );
> _POSIX_Timer_Free( ptimer );
> _Objects_Allocator_unlock();
>
> diff --git a/cpukit/posix/src/timergetoverrun.c
> b/cpukit/posix/src/timergetoverrun.c
> index dd7669e..0a28fa7 100644
> --- a/cpukit/posix/src/timergetoverrun.c
> +++ b/cpukit/posix/src/timergetoverrun.c
> @@ -33,14 +33,17 @@ int timer_getoverrun(
> int overrun;
> POSIX_Timer_Control *ptimer;
> Objects_Locations location;
> + ISR_lock_Context lock_context;
> + Per_CPU_Control *cpu;
>
> - ptimer = _POSIX_Timer_Get( timerid, &location );
> + ptimer = _POSIX_Timer_Get( timerid, &location, &lock_context );
> switch ( location ) {
>
> case OBJECTS_LOCAL:
> + cpu = _POSIX_Timer_Acquire_critical( ptimer, &lock_context );
> overrun = ptimer->overrun;
> ptimer->overrun = 0;
> - _Objects_Put( &ptimer->Object );
> + _POSIX_Timer_Release( cpu, &lock_context );
> return overrun;
>
> #if defined(RTEMS_MULTIPROCESSING)
> diff --git a/cpukit/posix/src/timergettime.c
> b/cpukit/posix/src/timergettime.c
> index f065cc9..7f0015b 100644
> --- a/cpukit/posix/src/timergettime.c
> +++ b/cpukit/posix/src/timergettime.c
> @@ -42,31 +42,32 @@ int timer_gettime(
> {
> POSIX_Timer_Control *ptimer;
> Objects_Locations location;
> - struct timespec current_time;
> - Watchdog_Interval left;
> + ISR_lock_Context lock_context;
> + Per_CPU_Control *cpu;
> + uint64_t now;
> + uint32_t remaining;
>
> if ( !value )
> rtems_set_errno_and_return_minus_one( EINVAL );
>
> - /* Reads the current time */
> - _TOD_Get_as_timespec( ¤t_time );
> -
> - ptimer = _POSIX_Timer_Get( timerid, &location );
> + ptimer = _POSIX_Timer_Get( timerid, &location, &lock_context );
> switch ( location ) {
>
> case OBJECTS_LOCAL:
>
> - /* Calculates the time left before the timer finishes */
> -
> - left =
> - (ptimer->Timer.start_time + ptimer->Timer.initial) - /* expire */
> - _Watchdog_Ticks_since_boot; /* now */
> + cpu = _POSIX_Timer_Acquire_critical( ptimer, &lock_context );
> + now = cpu->Watchdog.ticks;
>
> - _Timespec_From_ticks( left, &value->it_value );
> + if ( now < ptimer->Timer.expire ) {
> + remaining = (uint32_t) ( ptimer->Timer.expire - now );
> + } else {
> + remaining = 0;
> + }
>
> - value->it_interval = ptimer->timer_data.it_interval;
> + _Timespec_From_ticks( remaining, &value->it_value );
> + value->it_interval = ptimer->timer_data.it_interval;
>
> - _Objects_Put( &ptimer->Object );
> + _POSIX_Timer_Release( cpu, &lock_context );
> return 0;
>
> #if defined(RTEMS_MULTIPROCESSING)
> diff --git a/cpukit/posix/src/timerinserthelper.c
> b/cpukit/posix/src/timerinserthelper.c
> deleted file mode 100644
> index b1f3373..0000000
> --- a/cpukit/posix/src/timerinserthelper.c
> +++ /dev/null
> @@ -1,66 +0,0 @@
> -/**
> - * @file
> - *
> - * @brief Helper Routine for POSIX TIMERS
> - * @ingroup POSIXAPI
> - */
> -
> -/*
> - * Helper routine for POSIX timers
> - *
> - * COPYRIGHT (c) 1989-2007.
> - * On-Line Applications Research Corporation (OAR).
> - *
> - * The license and distribution terms for this file may be
> - * found in the file LICENSE in this distribution or at
> - * http://www.rtems.org/license/LICENSE.
> - */
> -
> -#if HAVE_CONFIG_H
> -#include "config.h"
> -#endif
> -
> -#include <time.h>
> -
> -#include <rtems/system.h>
> -#include <rtems/seterr.h>
> -#include <rtems/score/isr.h>
> -#include <rtems/score/watchdogimpl.h>
> -#include <rtems/posix/timerimpl.h>
> -#include <rtems/posix/ptimer.h>
> -
> -bool _POSIX_Timer_Insert_helper(
> - Watchdog_Control *timer,
> - Watchdog_Interval ticks,
> - Objects_Id id,
> - Watchdog_Service_routine_entry TSR,
> - void *arg
> -)
> -{
> - ISR_lock_Context lock_context;
> - Watchdog_Header *header;
> -
> - _Watchdog_Remove_ticks( timer );
> -
> - header = &_Watchdog_Ticks_header;
> - _Watchdog_Acquire( header, &lock_context );
> -
> - /*
> - * Check to see if the watchdog has just been inserted by a
> - * higher priority interrupt. If so, abandon this insert.
> - */
> - if ( timer->state != WATCHDOG_INACTIVE ) {
> - _Watchdog_Release( header, &lock_context );
> - return false;
> - }
> -
> - /*
> - * OK. Now we now the timer was not rescheduled by an interrupt
> - * so we can atomically initialize it as in use.
> - */
> - _Watchdog_Initialize( timer, TSR, id, arg );
> - timer->initial = ticks;
> - _Watchdog_Insert_locked( header, timer, &lock_context );
> - _Watchdog_Release( header, &lock_context );
> - return true;
> -}
> diff --git a/cpukit/posix/src/timersettime.c
> b/cpukit/posix/src/timersettime.c
> index fe54ff9..ac5c258 100644
> --- a/cpukit/posix/src/timersettime.c
> +++ b/cpukit/posix/src/timersettime.c
> @@ -29,6 +29,76 @@
> #include <rtems/score/watchdogimpl.h>
> #include <rtems/seterr.h>
>
> +static void _POSIX_Timer_Insert(
> + POSIX_Timer_Control *ptimer,
> + Per_CPU_Control *cpu,
> + Watchdog_Interval ticks
> +)
> +{
> + ptimer->ticks = ticks;
> +
> + /* The state really did not change but just to be safe */
> + ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;
> +
> + /* Store the time when the timer was started again */
> + _TOD_Get_as_timespec( &ptimer->time );
> +
> + _Watchdog_Insert(
> + &cpu->Watchdog.Header[ PER_CPU_WATCHDOG_RELATIVE ],
> + &ptimer->Timer,
> + cpu->Watchdog.ticks + ticks
> + );
> +}
> +
> +/*
> + * This is the operation that is run when a timer expires
> + */
> +void _POSIX_Timer_TSR( Watchdog_Control *the_watchdog )
> +{
> + POSIX_Timer_Control *ptimer;
> + ISR_lock_Context lock_context;
> + Per_CPU_Control *cpu;
> +
> + ptimer = RTEMS_CONTAINER_OF( the_watchdog, POSIX_Timer_Control, Timer );
> + _ISR_lock_ISR_disable( &lock_context );
> + cpu = _POSIX_Timer_Acquire_critical( ptimer, &lock_context );
> +
> + /* Increment the number of expirations. */
> + ptimer->overrun = ptimer->overrun + 1;
> +
> + /* The timer must be reprogrammed */
> + if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) ||
> + ( ptimer->timer_data.it_interval.tv_nsec != 0 ) ) {
> + _POSIX_Timer_Insert( ptimer, cpu, ptimer->ticks );
> + } else {
> + /* Indicates that the timer is stopped */
> + ptimer->state = POSIX_TIMER_STATE_CREATE_STOP;
> + }
> +
> + _POSIX_Timer_Release( cpu, &lock_context );
> +
> + /*
> + * The sending of the signal to the process running the handling
> function
> + * specified for that signal is simulated
> + */
> +
> + if ( pthread_kill ( ptimer->thread_id, ptimer->inf.sigev_signo ) ) {
> + _Assert( FALSE );
> + /*
> + * TODO: What if an error happens at run-time? This should never
> + * occur because the timer should be canceled if the thread
> + * is deleted. This method is being invoked from the Clock
> + * Tick ISR so even if we decide to take action on an error,
> + * we don't have many options. We shouldn't shut the system
> down.
> + */
> + }
> +
> + /* After the signal handler returns, the count of expirations of the
> + * timer must be set to 0.
> + */
> + ptimer->overrun = 0;
> +}
> +
> int timer_settime(
> timer_t timerid,
> int flags,
> @@ -38,7 +108,8 @@ int timer_settime(
> {
> POSIX_Timer_Control *ptimer;
> Objects_Locations location;
> - bool activated;
> + ISR_lock_Context lock_context;
> + Per_CPU_Control *cpu;
> uint32_t initial_period;
> struct itimerspec normalize;
>
> @@ -77,56 +148,47 @@ int timer_settime(
> * or start it again
> */
>
> - ptimer = _POSIX_Timer_Get( timerid, &location );
> + ptimer = _POSIX_Timer_Get( timerid, &location, &lock_context );
> switch ( location ) {
>
> case OBJECTS_LOCAL:
> + cpu = _POSIX_Timer_Acquire_critical( ptimer, &lock_context );
> +
> + /* Stop the timer */
> + _Watchdog_Remove(
> + &cpu->Watchdog.Header[ PER_CPU_WATCHDOG_RELATIVE ],
> + &ptimer->Timer
> + );
> +
> /* First, it verifies if the timer must be stopped */
> if ( normalize.it_value.tv_sec == 0 && normalize.it_value.tv_nsec
> == 0 ) {
> - /* Stop the timer */
> - _Watchdog_Remove_ticks( &ptimer->Timer );
> - /* The old data of the timer are returned */
> - if ( ovalue )
> - *ovalue = ptimer->timer_data;
> - /* The new data are set */
> - ptimer->timer_data = normalize;
> - /* Indicates that the timer is created and stopped */
> - ptimer->state = POSIX_TIMER_STATE_CREATE_STOP;
> - /* Returns with success */
> - _Objects_Put( &ptimer->Object );
> + /* The old data of the timer are returned */
> + if ( ovalue )
> + *ovalue = ptimer->timer_data;
> + /* The new data are set */
> + ptimer->timer_data = normalize;
> + /* Indicates that the timer is created and stopped */
> + ptimer->state = POSIX_TIMER_STATE_CREATE_STOP;
> + /* Returns with success */
> + _POSIX_Timer_Release( cpu, &lock_context );
> return 0;
> - }
> -
> - /* Convert from seconds and nanoseconds to ticks */
> - ptimer->ticks = _Timespec_To_ticks( &value->it_interval );
> - initial_period = _Timespec_To_ticks( &normalize.it_value );
> -
> -
> - activated = _POSIX_Timer_Insert_helper(
> - &ptimer->Timer,
> - initial_period,
> - ptimer->Object.id,
> - _POSIX_Timer_TSR,
> - ptimer
> - );
> - if ( !activated ) {
> - _Objects_Put( &ptimer->Object );
> - return 0;
> - }
> -
> - /*
> - * The timer has been started and is running. So we return the
> - * old ones in "ovalue"
> - */
> - if ( ovalue )
> - *ovalue = ptimer->timer_data;
> - ptimer->timer_data = normalize;
> -
> - /* Indicate that the time is running */
> - ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;
> - _TOD_Get_as_timespec( &ptimer->time );
> - _Objects_Put( &ptimer->Object );
> - return 0;
> + }
> +
> + /* Convert from seconds and nanoseconds to ticks */
> + ptimer->ticks = _Timespec_To_ticks( &value->it_interval );
> + initial_period = _Timespec_To_ticks( &normalize.it_value );
> +
> + _POSIX_Timer_Insert( ptimer, cpu, initial_period );
> +
> + /*
> + * The timer has been started and is running. So we return the
> + * old ones in "ovalue"
> + */
> + if ( ovalue )
> + *ovalue = ptimer->timer_data;
> + ptimer->timer_data = normalize;
> + _POSIX_Timer_Release( cpu, &lock_context );
> + return 0;
>
> #if defined(RTEMS_MULTIPROCESSING)
> case OBJECTS_REMOTE:
> diff --git a/cpukit/posix/src/timertsr.c b/cpukit/posix/src/timertsr.c
> deleted file mode 100644
> index 092bf16..0000000
> --- a/cpukit/posix/src/timertsr.c
> +++ /dev/null
> @@ -1,89 +0,0 @@
> -/**
> - * @file
> - *
> - * @brief Operation that is run when a timer expires
> - * @ingroup POSIX_INTERNAL_TIMERS Timers
> - */
> -
> -/*
> - * _POSIX_Timer_TSR
> - *
> - * COPYRIGHT (c) 1989-2007.
> - * On-Line Applications Research Corporation (OAR).
> - *
> - * The license and distribution terms for this file may be
> - * found in the file LICENSE in this distribution or at
> - * http://www.rtems.org/license/LICENSE.
> - */
> -
> -#if HAVE_CONFIG_H
> -#include "config.h"
> -#endif
> -
> -#include <time.h>
> -#include <pthread.h>
> -#include <signal.h>
> -
> -#include <rtems/posix/ptimer.h>
> -#include <rtems/posix/timerimpl.h>
> -#include <rtems/score/todimpl.h>
> -
> -/*
> - * This is the operation that is run when a timer expires
> - */
> -void _POSIX_Timer_TSR(
> - Objects_Id timer RTEMS_UNUSED,
> - void *data)
> -{
> - POSIX_Timer_Control *ptimer;
> - bool activated;
> -
> - ptimer = (POSIX_Timer_Control *)data;
> -
> - /* Increment the number of expirations. */
> - ptimer->overrun = ptimer->overrun + 1;
> -
> - /* The timer must be reprogrammed */
> - if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) ||
> - ( ptimer->timer_data.it_interval.tv_nsec != 0 ) ) {
> - activated = _POSIX_Timer_Insert_helper(
> - &ptimer->Timer,
> - ptimer->ticks,
> - ptimer->Object.id,
> - _POSIX_Timer_TSR,
> - ptimer
> - );
> - if ( !activated )
> - return;
> -
> - /* Store the time when the timer was started again */
> - _TOD_Get_as_timespec( &ptimer->time );
> -
> - /* The state really did not change but just to be safe */
> - ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;
> - } else {
> - /* Indicates that the timer is stopped */
> - ptimer->state = POSIX_TIMER_STATE_CREATE_STOP;
> - }
> -
> - /*
> - * The sending of the signal to the process running the handling
> function
> - * specified for that signal is simulated
> - */
> -
> - if ( pthread_kill ( ptimer->thread_id, ptimer->inf.sigev_signo ) ) {
> - _Assert( FALSE );
> - /*
> - * TODO: What if an error happens at run-time? This should never
> - * occur because the timer should be canceled if the thread
> - * is deleted. This method is being invoked from the Clock
> - * Tick ISR so even if we decide to take action on an error,
> - * we don't have many options. We shouldn't shut the system
> down.
> - */
> - }
> -
> - /* After the signal handler returns, the count of expirations of the
> - * timer must be set to 0.
> - */
> - ptimer->overrun = 0;
> -}
> diff --git a/cpukit/posix/src/ualarm.c b/cpukit/posix/src/ualarm.c
> index 9607d3f..27cd2eb 100644
> --- a/cpukit/posix/src/ualarm.c
> +++ b/cpukit/posix/src/ualarm.c
> @@ -21,39 +21,62 @@
> #include <signal.h>
> #include <unistd.h>
>
> -#include <rtems/posix/pthreadimpl.h>
> -#include <rtems/posix/psignalimpl.h>
> -#include <rtems/score/threaddispatch.h>
> #include <rtems/score/todimpl.h>
> #include <rtems/score/watchdogimpl.h>
> +#include <rtems/config.h>
>
> -static void _POSIX_signals_Ualarm_TSR( Objects_Id id, void *argument );
> +ISR_LOCK_DEFINE( static, _POSIX_signals_Ualarm_lock, "POSIX Ualarm" )
>
> -static Watchdog_Control _POSIX_signals_Ualarm_timer =
> WATCHDOG_INITIALIZER(
> - _POSIX_signals_Ualarm_TSR,
> - 0,
> - NULL
> -);
> -
> -/*
> - * _POSIX_signals_Ualarm_TSR
> - */
> +static uint32_t _POSIX_signals_Ualarm_interval;
>
> -static void _POSIX_signals_Ualarm_TSR(
> - Objects_Id id RTEMS_UNUSED,
> - void *argument RTEMS_UNUSED
> -)
> +static void _POSIX_signals_Ualarm_TSR( Watchdog_Control *the_watchdog )
> {
> - /*
> - * Send a SIGALRM but if there is a problem, ignore it.
> - * It's OK, there isn't a way this should fail.
> - */
> - (void) kill( getpid(), SIGALRM );
> + int status;
> + ISR_lock_Context lock_context;
> +
> + status = kill( getpid(), SIGALRM );
> +
> + #if defined(RTEMS_DEBUG)
> + /*
> + * There is no reason to think this might fail but we should be
> + * cautious.
> + */
> + _Assert(status == 0);
> + #else
> + (void) status;
> + #endif
> +
> + _ISR_lock_ISR_disable_and_acquire(
> + &_POSIX_signals_Ualarm_lock,
> + &lock_context
> + );
>
> /*
> * If the reset interval is non-zero, reschedule ourselves.
> */
> - _Watchdog_Reset_ticks( &_POSIX_signals_Ualarm_timer );
> + if ( _POSIX_signals_Ualarm_interval != 0 ) {
> + _Watchdog_Per_CPU_insert_relative(
> + the_watchdog,
> + _Per_CPU_Get(),
> + _POSIX_signals_Ualarm_interval
> + );
> + }
> +
> + _ISR_lock_Release_and_ISR_enable(
> + &_POSIX_signals_Ualarm_lock,
> + &lock_context
> + );
> +}
> +
> +static Watchdog_Control _POSIX_signals_Ualarm_watchdog =
> WATCHDOG_INITIALIZER(
> + _POSIX_signals_Ualarm_TSR
> +);
> +
> +static uint32_t _POSIX_signals_Ualarm_us_to_ticks( useconds_t us )
> +{
> + uint32_t us_per_tick = rtems_configuration_get_microseconds_per_tick();
> +
> + return ( us + us_per_tick - 1 ) / us_per_tick;
> }
>
> useconds_t ualarm(
> @@ -61,51 +84,53 @@ useconds_t ualarm(
> useconds_t interval
> )
> {
> - useconds_t remaining = 0;
> - Watchdog_Control *the_timer;
> - Watchdog_Interval ticks;
> - Watchdog_States state;
> - struct timespec tp;
> -
> - the_timer = &_POSIX_signals_Ualarm_timer;
> -
> - _Thread_Disable_dispatch();
> -
> - state = _Watchdog_Remove_ticks( the_timer );
> - if ( state == WATCHDOG_ACTIVE ) {
> - /*
> - * The stop_time and start_time fields are snapshots of ticks since
> - * boot. Since alarm() is dealing in seconds, we must account for
> - * this.
> - */
> -
> - ticks = the_timer->initial;
> - ticks -= (the_timer->stop_time - the_timer->start_time);
> - /* remaining is now in ticks */
> -
> - _Timespec_From_ticks( ticks, &tp );
> - remaining = tp.tv_sec * TOD_MICROSECONDS_PER_SECOND;
> - remaining += tp.tv_nsec / 1000;
> + useconds_t remaining;
> + Watchdog_Control *the_watchdog;
> + ISR_lock_Context lock_context;
> + ISR_lock_Context lock_context2;
> + Per_CPU_Control *cpu;
> + uint64_t now;
> + uint32_t ticks_initial;
> + uint32_t ticks_interval;
> +
> + the_watchdog = &_POSIX_signals_Ualarm_watchdog;
> + ticks_initial = _POSIX_signals_Ualarm_us_to_ticks( useconds );
> + ticks_interval = _POSIX_signals_Ualarm_us_to_ticks( interval );
> +
> + _ISR_lock_ISR_disable_and_acquire(
> + &_POSIX_signals_Ualarm_lock,
> + &lock_context
> + );
> +
> + cpu = _Watchdog_Get_CPU( the_watchdog );
> + _Watchdog_Per_CPU_acquire( cpu, &lock_context2 );
> + now = cpu->Watchdog.ticks;
> +
> + remaining = (useconds_t) _Watchdog_Cancel(
> + &cpu->Watchdog.Header[ PER_CPU_WATCHDOG_RELATIVE ],
> + the_watchdog,
> + now
> + );
> +
> + if ( ticks_initial != 0 ) {
> + _POSIX_signals_Ualarm_interval = ticks_interval;
> +
> + cpu = _Per_CPU_Get();
> + _Watchdog_Set_CPU( the_watchdog, cpu );
> + _Watchdog_Insert(
> + &cpu->Watchdog.Header[ PER_CPU_WATCHDOG_RELATIVE ],
> + the_watchdog,
> + now + ticks_initial
> + );
> }
>
> - /*
> - * If useconds is non-zero, then the caller wants to schedule
> - * the alarm repeatedly at that interval. If the interval is
> - * less than a single clock tick, then fudge it to a clock tick.
> - */
> - if ( useconds ) {
> - Watchdog_Interval ticks;
> -
> - tp.tv_sec = useconds / TOD_MICROSECONDS_PER_SECOND;
> - tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000;
> - ticks = _Timespec_To_ticks( &tp );
> - if ( ticks == 0 )
> - ticks = 1;
> -
> - _Watchdog_Insert_ticks( the_timer, _Timespec_To_ticks( &tp ) );
> - }
> + _Watchdog_Per_CPU_release( cpu, &lock_context2 );
> + _ISR_lock_Release_and_ISR_enable(
> + &_POSIX_signals_Ualarm_lock,
> + &lock_context
> + );
>
> - _Thread_Enable_dispatch();
> + remaining *= rtems_configuration_get_microseconds_per_tick();
>
> return remaining;
> }
> diff --git a/cpukit/rtems/include/rtems/rtems/ratemonimpl.h
> b/cpukit/rtems/include/rtems/rtems/ratemonimpl.h
> index 490912e..f184c44 100644
> --- a/cpukit/rtems/include/rtems/rtems/ratemonimpl.h
> +++ b/cpukit/rtems/include/rtems/rtems/ratemonimpl.h
> @@ -129,19 +129,13 @@ RTEMS_INLINE_ROUTINE bool _Rate_monotonic_Is_expired
> (
> /**
> * @brief Rate Monotonic Timeout
> *
> - * This routine is invoked when the period represented
> - * by ID expires. If the thread which owns this period is blocked
> - * waiting for the period to expire, then it is readied and the
> - * period is restarted. If the owning thread is not waiting for the
> - * period to expire, then the period is placed in the EXPIRED
> - * state and not restarted.
> - *
> - * @param[in] id is the period id
> - */
> -void _Rate_monotonic_Timeout(
> - rtems_id id,
> - void *ignored
> -);
> + * This routine is invoked when the period represented by the watchdog
> expires.
> + * If the thread which owns this period is blocked waiting for the period
> to
> + * expire, then it is readied and the period is restarted. If the owning
> thread
> + * is not waiting for the period to expire, then the period is placed in
> the
> + * EXPIRED state and not restarted.
> + */
> +void _Rate_monotonic_Timeout( Watchdog_Control *watchdog );
>
> /**
> * @brief _Rate_monotonic_Get_status(
> @@ -165,7 +159,7 @@ bool _Rate_monotonic_Get_status(
> );
>
> /**
> - * @brief Initiate Rate Monotonic Statistics
> + * @brief Restart Rate Monotonic Period
> *
> * This routine is invoked when a period is initiated via an explicit
> * call to rtems_rate_monotonic_period for the period's first iteration
> @@ -173,7 +167,7 @@ bool _Rate_monotonic_Get_status(
> *
> * @param[in] the_period points to the period being operated upon.
> */
> -void _Rate_monotonic_Initiate_statistics(
> +void _Rate_monotonic_Restart(
> Rate_monotonic_Control *the_period
> );
>
> diff --git a/cpukit/rtems/include/rtems/rtems/timer.h
> b/cpukit/rtems/include/rtems/rtems/timer.h
> index 7cc9051..032c495 100644
> --- a/cpukit/rtems/include/rtems/rtems/timer.h
> +++ b/cpukit/rtems/include/rtems/rtems/timer.h
> @@ -31,7 +31,7 @@
> * COPYRIGHT (c) 1989-2011.
> * On-Line Applications Research Corporation (OAR).
> *
> - * Copyright (c) 2009 embedded brains GmbH.
> + * Copyright (c) 2009, 2016 embedded brains GmbH.
> *
> * The license and distribution terms for this file may be
> * found in the file LICENSE in this distribution or at
> @@ -43,6 +43,7 @@
>
> #include <rtems/rtems/attr.h>
> #include <rtems/rtems/status.h>
> +#include <rtems/rtems/tasks.h>
> #include <rtems/rtems/types.h>
>
> #ifdef __cplusplus
> @@ -63,39 +64,49 @@ extern "C" {
> */
> /**@{*/
>
> +#define TIMER_CLASS_BIT_TIME_OF_DAY 0x1
> +
> +#define TIMER_CLASS_BIT_ON_TASK 0x2
> +
> +#define TIMER_CLASS_BIT_NOT_DORMANT 0x4
> +
> /**
> * The following enumerated type details the classes to which a timer
> * may belong.
> */
> typedef enum {
> /**
> + * This value indicates the timer is currently not in use.
> + */
> + TIMER_DORMANT,
> +
> + /**
> * This value indicates the timer is currently in use as an interval
> * timer which will fire in the clock tick ISR.
> */
> - TIMER_INTERVAL,
> + TIMER_INTERVAL = TIMER_CLASS_BIT_NOT_DORMANT,
>
> /**
> * This value indicates the timer is currently in use as an interval
> * timer which will fire in the timer server task.
> */
> - TIMER_INTERVAL_ON_TASK,
> + TIMER_INTERVAL_ON_TASK =
> + TIMER_CLASS_BIT_NOT_DORMANT | TIMER_CLASS_BIT_ON_TASK,
>
> /**
> * This value indicates the timer is currently in use as an time of day
> * timer which will fire in the clock tick ISR.
> */
> - TIMER_TIME_OF_DAY,
> + TIMER_TIME_OF_DAY =
> + TIMER_CLASS_BIT_NOT_DORMANT | TIMER_CLASS_BIT_TIME_OF_DAY,
>
> /**
> * This value indicates the timer is currently in use as an time of day
> * timer which will fire in the timer server task.
> */
> - TIMER_TIME_OF_DAY_ON_TASK,
> -
> - /**
> - * This value indicates the timer is currently not in use.
> - */
> - TIMER_DORMANT
> + TIMER_TIME_OF_DAY_ON_TASK =
> + TIMER_CLASS_BIT_NOT_DORMANT | TIMER_CLASS_BIT_TIME_OF_DAY |
> + TIMER_CLASS_BIT_ON_TASK
> } Timer_Classes;
>
> /**
> @@ -124,6 +135,16 @@ typedef struct {
> Watchdog_Control Ticker;
> /** This field indicates what type of timer this currently is. */
> Timer_Classes the_class;
> + /** This field is the timer service routine. */
> + rtems_timer_service_routine_entry routine;
> + /** This field is the timer service routine user data. */
> + void *user_data;
> + /** This field is the timer interval in ticks or seconds. */
> + Watchdog_Interval initial;
> + /** This field is the timer start time point in ticks. */
> + Watchdog_Interval start_time;
> + /** This field is the timer stop time point in ticks. */
> + Watchdog_Interval stop_time;
> } Timer_Control;
>
> /**
> @@ -296,16 +317,22 @@ rtems_status_code rtems_timer_reset(
> );
>
> /**
> - * @brief rtems_timer_initiate_server
> + * @brief Initiates the timer server.
> *
> - * This routine implements the rtems_timer_initiate_server directive.
> - * It creates and starts the server that executes task-based timers.
> + * This directive creates and starts the server for task-based timers.
> * It must be invoked before any task-based timers can be initiated.
> + *
> + * @param priority The timer server task priority.
> + * @param stack_size The stack size in bytes for the timer server task.
> + * @param attribute_set The timer server task attributes.
> + *
> + * @return This method returns RTEMS_SUCCESSFUL if successful and an
> + * error code otherwise.
> */
> rtems_status_code rtems_timer_initiate_server(
> - uint32_t priority,
> - uint32_t stack_size,
> - rtems_attribute attribute_set
> + rtems_task_priority priority,
> + size_t stack_size,
> + rtems_attribute attribute_set
> );
>
> /**
> diff --git a/cpukit/rtems/include/rtems/rtems/timerimpl.h
> b/cpukit/rtems/include/rtems/rtems/timerimpl.h
> index 55be634..59ba09b 100644
> --- a/cpukit/rtems/include/rtems/rtems/timerimpl.h
> +++ b/cpukit/rtems/include/rtems/rtems/timerimpl.h
> @@ -10,6 +10,8 @@
> * COPYRIGHT (c) 1989-2011.
> * On-Line Applications Research Corporation (OAR).
> *
> + * Copyright (c) 2016 embedded brains GmbH.
> + *
> * The license and distribution terms for this file may be
> * found in the file LICENSE in this distribution or at
> * http://www.rtems.org/license/LICENSE.
> @@ -35,81 +37,13 @@ extern "C" {
> * @{
> */
>
> -typedef struct Timer_server_Control Timer_server_Control;
> +typedef struct Timer_server_Control {
> + ISR_LOCK_MEMBER( Lock )
>
> -/**
> - * @brief Method used for task based timers.
> - */
> -typedef void (*Timer_server_Method)(
> - Timer_server_Control *timer_server,
> - Timer_Control *timer
> -);
> + Chain_Control Pending;
>
> -typedef struct {
> - /**
> - * @brief This watchdog that will be registered in the system tick
> mechanic
> - * for timer server wake-up.
> - */
> - Watchdog_Control System_watchdog;
> -
> - /**
> - * @brief Remaining delta of the system watchdog.
> - */
> - Watchdog_Interval system_watchdog_delta;
> -
> - /**
> - * @brief Unique identifier of the context which deals currently with
> the
> - * system watchdog.
> - */
> - Thread_Control *system_watchdog_helper;
> -
> - /**
> - * @brief Each insert and tickle operation increases the generation
> count so
> - * that the system watchdog dealer notices updates of the watchdog
> chain.
> - */
> - uint32_t generation;
> -
> - /**
> - * @brief Watchdog header managed by the timer server.
> - */
> - Watchdog_Header Header;
> -
> - /**
> - * @brief Last time snapshot of the timer server.
> - *
> - * The units may be ticks or seconds.
> - */
> - Watchdog_Interval last_snapshot;
> -
> - /**
> - * @brief Current time snapshot of the timer server.
> - *
> - * The units may be ticks or seconds.
> - */
> - Watchdog_Interval current_snapshot;
> -} Timer_server_Watchdogs;
> -
> -struct Timer_server_Control {
> - /**
> - * @brief The cancel method of the timer server.
> - */
> - Timer_server_Method cancel;
> -
> - /**
> - * @brief The schedule operation method of the timer server.
> - */
> - Timer_server_Method schedule_operation;
> -
> - /**
> - * @brief Interval watchdogs triggered by the timer server.
> - */
> - Timer_server_Watchdogs Interval_watchdogs;
> -
> - /**
> - * @brief TOD watchdogs triggered by the timer server.
> - */
> - Timer_server_Watchdogs TOD_watchdogs;
> -};
> + Objects_Id server_id;
> +} Timer_server_Control;
>
> /**
> * @brief Pointer to default timer server control block.
> @@ -148,64 +82,124 @@ RTEMS_INLINE_ROUTINE void _Timer_Free (
> _Objects_Free( &_Timer_Information, &the_timer->Object );
> }
>
> -/**
> - * @brief Timer_Get
> - *
> - * This function maps timer IDs to timer control blocks.
> - * If ID corresponds to a local timer, then it returns
> - * the timer control pointer which maps to ID and location
> - * is set to OBJECTS_LOCAL. Otherwise, location is set
> - * to OBJECTS_ERROR and the returned value is undefined.
> - */
> -RTEMS_INLINE_ROUTINE Timer_Control *_Timer_Get (
> +RTEMS_INLINE_ROUTINE Timer_Control *_Timer_Get(
> Objects_Id id,
> - Objects_Locations *location
> + Objects_Locations *location,
> + ISR_lock_Context *lock_context
> )
> {
> - return (Timer_Control *)
> - _Objects_Get( &_Timer_Information, id, location );
> + return (Timer_Control *) _Objects_Get_isr_disable(
> + &_Timer_Information,
> + id,
> + location,
> + lock_context
> + );
> }
>
> -/**
> - * @brief Timer_Is_interval_class
> - *
> - * This function returns TRUE if the class is that of an INTERVAL
> - * timer, and FALSE otherwise.
> - */
> -RTEMS_INLINE_ROUTINE bool _Timer_Is_interval_class (
> +RTEMS_INLINE_ROUTINE Per_CPU_Control *_Timer_Acquire_critical(
> + Timer_Control *the_timer,
> + ISR_lock_Context *lock_context
> +)
> +{
> + Per_CPU_Control *cpu;
> +
> + cpu = _Watchdog_Get_CPU( &the_timer->Ticker );
> + _Watchdog_Per_CPU_acquire( cpu, lock_context );
> +
> + return cpu;
> +}
> +
> +RTEMS_INLINE_ROUTINE void _Timer_Release(
> + Per_CPU_Control *cpu,
> + ISR_lock_Context *lock_context
> +)
> +{
> + _Watchdog_Per_CPU_release( cpu, lock_context );
> + _ISR_lock_ISR_enable( lock_context );
> +}
> +
> +RTEMS_INLINE_ROUTINE bool _Timer_Is_interval_class(
> Timer_Classes the_class
> )
> {
> - return (the_class == TIMER_INTERVAL) || (the_class ==
> TIMER_INTERVAL_ON_TASK);
> + Timer_Classes mask =
> + TIMER_CLASS_BIT_NOT_DORMANT | TIMER_CLASS_BIT_TIME_OF_DAY;
> +
> + return ( the_class & mask ) == TIMER_CLASS_BIT_NOT_DORMANT;
> }
>
> -/**
> - * @brief Timer_Is_time_of_day_class
> - *
> - * This function returns TRUE if the class is that of an INTERVAL
> - * timer, and FALSE otherwise.
> - */
> -RTEMS_INLINE_ROUTINE bool _Timer_Is_timer_of_day_class (
> +RTEMS_INLINE_ROUTINE bool _Timer_Is_on_task_class(
> Timer_Classes the_class
> )
> {
> - return ( the_class == TIMER_TIME_OF_DAY );
> + Timer_Classes mask =
> + TIMER_CLASS_BIT_NOT_DORMANT | TIMER_CLASS_BIT_ON_TASK;
> +
> + return ( the_class & mask ) == mask;
> }
>
> -/**
> - * @brief Timer_Is_dormant_class
> - *
> - * This function returns TRUE if the class is that of a DORMANT
> - * timer, and FALSE otherwise.
> - */
> -RTEMS_INLINE_ROUTINE bool _Timer_Is_dormant_class (
> +RTEMS_INLINE_ROUTINE Per_CPU_Watchdog_index _Timer_Watchdog_header_index(
> Timer_Classes the_class
> )
> {
> - return ( the_class == TIMER_DORMANT );
> + return ( the_class & TIMER_CLASS_BIT_TIME_OF_DAY );
> +}
> +
> +RTEMS_INLINE_ROUTINE Watchdog_Interval _Timer_Get_CPU_ticks(
> + const Per_CPU_Control *cpu
> +)
> +{
> + return (Watchdog_Interval) cpu->Watchdog.ticks;
> }
>
> -void _Timer_Cancel( Timer_Control *the_timer );
> +rtems_status_code _Timer_Fire(
> + rtems_id id,
> + rtems_interval interval,
> + rtems_timer_service_routine_entry routine,
> + void *user_data,
> + Timer_Classes the_class,
> + Watchdog_Service_routine_entry adaptor
> +);
> +
> +rtems_status_code _Timer_Fire_after(
> + rtems_id id,
> + rtems_interval ticks,
> + rtems_timer_service_routine_entry routine,
> + void *user_data,
> + Timer_Classes the_class,
> + Watchdog_Service_routine_entry adaptor
> +);
> +
> +rtems_status_code _Timer_Fire_when(
> + rtems_id id,
> + const rtems_time_of_day *wall_time,
> + rtems_timer_service_routine_entry routine,
> + void *user_data,
> + Timer_Classes the_class,
> + Watchdog_Service_routine_entry adaptor
> +);
> +
> +void _Timer_Cancel( Per_CPU_Control *cpu, Timer_Control *the_timer );
> +
> +void _Timer_Routine_adaptor( Watchdog_Control *the_watchdog );
> +
> +void _Timer_server_Routine_adaptor( Watchdog_Control *the_watchdog );
> +
> +RTEMS_INLINE_ROUTINE void _Timer_server_Acquire_critical(
> + Timer_server_Control *timer_server,
> + ISR_lock_Context *lock_context
> +)
> +{
> + _ISR_lock_Acquire( &timer_server->Lock, lock_context );
> +}
> +
> +RTEMS_INLINE_ROUTINE void _Timer_server_Release_critical(
> + Timer_server_Control *timer_server,
> + ISR_lock_Context *lock_context
> +)
> +{
> + _ISR_lock_Release( &timer_server->Lock, lock_context );
> +}
>
> /**@}*/
>
> diff --git a/cpukit/rtems/src/eventseize.c b/cpukit/rtems/src/eventseize.c
> index 3dc554f..0be6bd6 100644
> --- a/cpukit/rtems/src/eventseize.c
> +++ b/cpukit/rtems/src/eventseize.c
> @@ -90,13 +90,12 @@ void _Event_Seize(
>
> if ( ticks ) {
> _Thread_Wait_set_timeout_code( executing, RTEMS_TIMEOUT );
> - _Watchdog_Initialize(
> - &executing->Timer,
> + _Thread_Timer_insert_relative(
> + executing,
> + cpu_self,
> _Thread_Timeout,
> - 0,
> - executing
> + ticks
> );
> - _Watchdog_Insert_ticks( &executing->Timer, ticks );
> }
>
> _Thread_Set_state( executing, block_state );
> @@ -113,7 +112,7 @@ void _Event_Seize(
> wait_class | THREAD_WAIT_STATE_BLOCKED
> );
> if ( !success ) {
> - _Watchdog_Remove_ticks( &executing->Timer );
> + _Thread_Timer_remove( executing );
> _Thread_Unblock( executing );
> }
>
> diff --git a/cpukit/rtems/src/eventsurrender.c
> b/cpukit/rtems/src/eventsurrender.c
> index 5726cc8..7c4fe2e 100644
> --- a/cpukit/rtems/src/eventsurrender.c
> +++ b/cpukit/rtems/src/eventsurrender.c
> @@ -121,7 +121,7 @@ void _Event_Surrender(
> cpu_self = _Thread_Dispatch_disable_critical( lock_context );
> _Thread_Lock_release_default( the_thread, lock_context );
>
> - _Watchdog_Remove_ticks( &the_thread->Timer );
> + _Thread_Timer_remove( the_thread );
> _Thread_Unblock( the_thread );
>
> _Thread_Dispatch_enable( cpu_self );
> diff --git a/cpukit/rtems/src/ratemoncancel.c
> b/cpukit/rtems/src/ratemoncancel.c
> index 67b230f..2e4d532 100644
> --- a/cpukit/rtems/src/ratemoncancel.c
> +++ b/cpukit/rtems/src/ratemoncancel.c
> @@ -29,6 +29,7 @@ rtems_status_code rtems_rate_monotonic_cancel(
> {
> Rate_monotonic_Control *the_period;
> Objects_Locations location;
> + ISR_Level level;
>
> the_period = _Rate_monotonic_Get( id, &location );
> switch ( location ) {
> @@ -38,7 +39,9 @@ rtems_status_code rtems_rate_monotonic_cancel(
> _Objects_Put( &the_period->Object );
> return RTEMS_NOT_OWNER_OF_RESOURCE;
> }
> - _Watchdog_Remove_ticks( &the_period->Timer );
> + _ISR_Disable( level );
> + _Watchdog_Per_CPU_remove_relative( &the_period->Timer );
> + _ISR_Enable( level );
> the_period->state = RATE_MONOTONIC_INACTIVE;
> _Scheduler_Release_job( the_period->owner, 0 );
> _Objects_Put( &the_period->Object );
> diff --git a/cpukit/rtems/src/ratemoncreate.c
> b/cpukit/rtems/src/ratemoncreate.c
> index 1ac4a36..1a5c9b2 100644
> --- a/cpukit/rtems/src/ratemoncreate.c
> +++ b/cpukit/rtems/src/ratemoncreate.c
> @@ -65,7 +65,8 @@ rtems_status_code rtems_rate_monotonic_create(
> the_period->owner = _Thread_Get_executing();
> the_period->state = RATE_MONOTONIC_INACTIVE;
>
> - _Watchdog_Preinitialize( &the_period->Timer );
> + _Watchdog_Preinitialize( &the_period->Timer, _Per_CPU_Get_by_index( 0 )
> );
> + _Watchdog_Initialize( &the_period->Timer, _Rate_monotonic_Timeout );
>
> _Rate_monotonic_Reset_statistics( the_period );
>
> diff --git a/cpukit/rtems/src/ratemondelete.c
> b/cpukit/rtems/src/ratemondelete.c
> index 77cf3fe..09b9ab6 100644
> --- a/cpukit/rtems/src/ratemondelete.c
> +++ b/cpukit/rtems/src/ratemondelete.c
> @@ -29,6 +29,7 @@ rtems_status_code rtems_rate_monotonic_delete(
> {
> Rate_monotonic_Control *the_period;
> Objects_Locations location;
> + ISR_Level level;
>
> _Objects_Allocator_lock();
> the_period = _Rate_monotonic_Get( id, &location );
> @@ -37,7 +38,9 @@ rtems_status_code rtems_rate_monotonic_delete(
> case OBJECTS_LOCAL:
> _Scheduler_Release_job( the_period->owner, 0 );
> _Objects_Close( &_Rate_monotonic_Information, &the_period->Object );
> - _Watchdog_Remove_ticks( &the_period->Timer );
> + _ISR_Disable( level );
> + _Watchdog_Per_CPU_remove_relative( &the_period->Timer );
> + _ISR_Enable( level );
> the_period->state = RATE_MONOTONIC_INACTIVE;
> _Objects_Put( &the_period->Object );
> _Rate_monotonic_Free( the_period );
> diff --git a/cpukit/rtems/src/ratemonperiod.c
> b/cpukit/rtems/src/ratemonperiod.c
> index 6afe101..58be148 100644
> --- a/cpukit/rtems/src/ratemonperiod.c
> +++ b/cpukit/rtems/src/ratemonperiod.c
> @@ -77,12 +77,11 @@ bool _Rate_monotonic_Get_status(
> return true;
> }
>
> -void _Rate_monotonic_Initiate_statistics(
> - Rate_monotonic_Control *the_period
> -)
> +void _Rate_monotonic_Restart( Rate_monotonic_Control *the_period )
> {
> Thread_Control *owning_thread = the_period->owner;
> Timestamp_Control uptime;
> + ISR_Level level;
>
> _TOD_Get_uptime( &uptime );
>
> @@ -113,7 +112,15 @@ void _Rate_monotonic_Initiate_statistics(
> _Timestamp_Add_to( &the_period->cpu_usage_period_initiated, &ran );
> }
>
> - _Scheduler_Release_job( the_period->owner, the_period->next_length );
> + _Scheduler_Release_job( owning_thread, the_period->next_length );
> +
> + _ISR_Disable( level );
> + _Watchdog_Per_CPU_insert_relative(
> + &the_period->Timer,
> + _Per_CPU_Get(),
> + the_period->next_length
> + );
> + _ISR_Enable( level );
> }
>
> static void _Rate_monotonic_Update_statistics(
> @@ -238,22 +245,9 @@ rtems_status_code rtems_rate_monotonic_period(
> if ( the_period->state == RATE_MONOTONIC_INACTIVE ) {
> _ISR_Enable( level );
>
> - the_period->next_length = length;
> -
> - /*
> - * Baseline statistics information for the beginning of a period.
> - */
> - _Rate_monotonic_Initiate_statistics( the_period );
> -
> the_period->state = RATE_MONOTONIC_ACTIVE;
> - _Watchdog_Initialize(
> - &the_period->Timer,
> - _Rate_monotonic_Timeout,
> - id,
> - NULL
> - );
> -
> - _Watchdog_Insert_ticks( &the_period->Timer, length );
> + the_period->next_length = length;
> + _Rate_monotonic_Restart( the_period );
> _Objects_Put( &the_period->Object );
> return RTEMS_SUCCESSFUL;
> }
> @@ -308,7 +302,11 @@ rtems_status_code rtems_rate_monotonic_period(
> the_period->state = RATE_MONOTONIC_ACTIVE;
> the_period->next_length = length;
>
> - _Watchdog_Insert_ticks( &the_period->Timer, length );
> + _Watchdog_Per_CPU_insert_relative(
> + &the_period->Timer,
> + _Per_CPU_Get(),
> + length
> + );
> _Scheduler_Release_job( the_period->owner,
> the_period->next_length );
> _Objects_Put( &the_period->Object );
> return RTEMS_TIMEOUT;
> diff --git a/cpukit/rtems/src/ratemontimeout.c
> b/cpukit/rtems/src/ratemontimeout.c
> index 08f9bd1..7c25595 100644
> --- a/cpukit/rtems/src/ratemontimeout.c
> +++ b/cpukit/rtems/src/ratemontimeout.c
> @@ -22,46 +22,30 @@
> #include <rtems/score/threadimpl.h>
> #include <rtems/score/watchdogimpl.h>
>
> -void _Rate_monotonic_Timeout(
> - Objects_Id id,
> - void *ignored
> -)
> +void _Rate_monotonic_Timeout( Watchdog_Control *watchdog )
> {
> Rate_monotonic_Control *the_period;
> - Objects_Locations location;
> Thread_Control *the_thread;
>
> /*
> * When we get here, the Timer is already off the chain so we do not
> * have to worry about that -- hence no _Watchdog_Remove().
> */
> - the_period = _Rate_monotonic_Get( id, &location );
> - switch ( location ) {
> -
> - case OBJECTS_LOCAL:
> - the_thread = the_period->owner;
> - if ( _States_Is_waiting_for_period( the_thread->current_state ) &&
> - the_thread->Wait.id == the_period->Object.id ) {
> - _Thread_Unblock( the_thread );
> -
> - _Rate_monotonic_Initiate_statistics( the_period );
> -
> - _Watchdog_Insert_ticks( &the_period->Timer,
> the_period->next_length );
> - } else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING )
> {
> - the_period->state = RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING;
> -
> - _Rate_monotonic_Initiate_statistics( the_period );
> -
> - _Watchdog_Insert_ticks( &the_period->Timer,
> the_period->next_length );
> - } else
> - the_period->state = RATE_MONOTONIC_EXPIRED;
> - _Objects_Put_without_thread_dispatch( &the_period->Object );
> - break;
> -
> -#if defined(RTEMS_MULTIPROCESSING)
> - case OBJECTS_REMOTE: /* impossible */
> -#endif
> - case OBJECTS_ERROR:
> - break;
> + the_period = RTEMS_CONTAINER_OF( watchdog, Rate_monotonic_Control,
> Timer );
> + the_thread = the_period->owner;
> +
> + _Thread_Disable_dispatch();
> +
> + if ( _States_Is_waiting_for_period( the_thread->current_state ) &&
> + the_thread->Wait.id == the_period->Object.id ) {
> + _Thread_Unblock( the_thread );
> + _Rate_monotonic_Restart( the_period );
> + } else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) {
> + the_period->state = RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING;
> + _Rate_monotonic_Restart( the_period );
> + } else {
> + the_period->state = RATE_MONOTONIC_EXPIRED;
> }
> +
> + _Thread_Unnest_dispatch();
> }
> diff --git a/cpukit/rtems/src/taskwakeafter.c
> b/cpukit/rtems/src/taskwakeafter.c
> index b7f328f..fa5f6f4 100644
> --- a/cpukit/rtems/src/taskwakeafter.c
> +++ b/cpukit/rtems/src/taskwakeafter.c
> @@ -41,13 +41,12 @@ rtems_status_code rtems_task_wake_after(
> } else {
> _Thread_Set_state( executing, STATES_DELAYING );
> _Thread_Wait_flags_set( executing, THREAD_WAIT_STATE_BLOCKED );
> - _Watchdog_Initialize(
> - &executing->Timer,
> + _Thread_Timer_insert_relative(
> + executing,
> + cpu_self,
> _Thread_Timeout,
> - 0,
> - executing
> + ticks
> );
> - _Watchdog_Insert_ticks( &executing->Timer, ticks );
> }
> _Thread_Dispatch_enable( cpu_self );
> return RTEMS_SUCCESSFUL;
> diff --git a/cpukit/rtems/src/taskwakewhen.c
> b/cpukit/rtems/src/taskwakewhen.c
> index cf0b303..5d6d45a 100644
> --- a/cpukit/rtems/src/taskwakewhen.c
> +++ b/cpukit/rtems/src/taskwakewhen.c
> @@ -28,9 +28,9 @@ rtems_status_code rtems_task_wake_when(
> rtems_time_of_day *time_buffer
> )
> {
> - Watchdog_Interval seconds;
> - Thread_Control *executing;
> - Per_CPU_Control *cpu_self;
> + uint32_t seconds;
> + Thread_Control *executing;
> + Per_CPU_Control *cpu_self;
>
> if ( !_TOD_Is_set() )
> return RTEMS_NOT_DEFINED;
> @@ -52,15 +52,11 @@ rtems_status_code rtems_task_wake_when(
> executing = _Thread_Executing;
> _Thread_Set_state( executing, STATES_WAITING_FOR_TIME );
> _Thread_Wait_flags_set( executing, THREAD_WAIT_STATE_BLOCKED );
> - _Watchdog_Initialize(
> - &executing->Timer,
> + _Thread_Timer_insert_absolute(
> + executing,
> + cpu_self,
> _Thread_Timeout,
> - 0,
> - executing
> - );
> - _Watchdog_Insert_seconds(
> - &executing->Timer,
> - seconds - _TOD_Seconds_since_epoch()
> + _Watchdog_Ticks_from_seconds( seconds )
> );
> _Thread_Dispatch_enable( cpu_self );
> return RTEMS_SUCCESSFUL;
> diff --git a/cpukit/rtems/src/timercancel.c
> b/cpukit/rtems/src/timercancel.c
> index 1e737a2..5d4343e 100644
> --- a/cpukit/rtems/src/timercancel.c
> +++ b/cpukit/rtems/src/timercancel.c
> @@ -14,39 +14,24 @@
> #include "config.h"
> #endif
>
> -#include <rtems/system.h>
> -#include <rtems/rtems/status.h>
> -#include <rtems/rtems/support.h>
> -#include <rtems/score/thread.h>
> #include <rtems/rtems/timerimpl.h>
> -#include <rtems/score/watchdogimpl.h>
> -
> -/*
> - * rtems_timer_cancel
> - *
> - * This directive allows a thread to cancel a timer.
> - *
> - * Input parameters:
> - * id - timer id
> - *
> - * Output parameters:
> - * RTEMS_SUCCESSFUL - if successful
> - * error code - if unsuccessful
> - */
>
> rtems_status_code rtems_timer_cancel(
> rtems_id id
> )
> {
> - Timer_Control *the_timer;
> - Objects_Locations location;
> + Timer_Control *the_timer;
> + Objects_Locations location;
> + ISR_lock_Context lock_context;
> + Per_CPU_Control *cpu;
>
> - the_timer = _Timer_Get( id, &location );
> + the_timer = _Timer_Get( id, &location, &lock_context );
> switch ( location ) {
>
> case OBJECTS_LOCAL:
> - _Timer_Cancel( the_timer );
> - _Objects_Put( &the_timer->Object );
> + cpu = _Timer_Acquire_critical( the_timer, &lock_context );
> + _Timer_Cancel( cpu, the_timer );
> + _Timer_Release( cpu, &lock_context );
> return RTEMS_SUCCESSFUL;
>
> #if defined(RTEMS_MULTIPROCESSING)
> diff --git a/cpukit/rtems/src/timercreate.c
> b/cpukit/rtems/src/timercreate.c
> index 5c718b9..80c1356 100644
> --- a/cpukit/rtems/src/timercreate.c
> +++ b/cpukit/rtems/src/timercreate.c
> @@ -18,40 +18,173 @@
> #include "config.h"
> #endif
>
> -#include <rtems/system.h>
> +#include <rtems/rtems/timerimpl.h>
> +#include <rtems/rtems/clock.h>
> #include <rtems/rtems/status.h>
> #include <rtems/rtems/support.h>
> #include <rtems/score/assert.h>
> +#include <rtems/score/chainimpl.h>
> #include <rtems/score/thread.h>
> -#include <rtems/rtems/timerimpl.h>
> +#include <rtems/score/todimpl.h>
> #include <rtems/score/watchdogimpl.h>
>
> -void _Timer_Cancel( Timer_Control *the_timer )
> +RTEMS_STATIC_ASSERT(
> + PER_CPU_WATCHDOG_ABSOLUTE == TIMER_CLASS_BIT_TIME_OF_DAY,
> + TIMER_CLASS_BIT_TIME_OF_DAY
> +);
> +
> +void _Timer_Routine_adaptor( Watchdog_Control *the_watchdog )
> {
> - Timer_server_Control *timer_server;
> - ISR_Level level;
> + Timer_Control *the_timer;
> + Per_CPU_Control *cpu;
>
> - /* The timer class must not change during the cancel operation */
> - _ISR_Disable( level );
> + the_timer = RTEMS_CONTAINER_OF( the_watchdog, Timer_Control, Ticker );
> + cpu = _Watchdog_Get_CPU( &the_timer->Ticker );
> + the_timer->stop_time = _Timer_Get_CPU_ticks( cpu );
>
> - switch ( the_timer->the_class ) {
> - case TIMER_INTERVAL:
> - _Watchdog_Remove_ticks( &the_timer->Ticker );
> - break;
> - case TIMER_TIME_OF_DAY:
> - _Watchdog_Remove_seconds( &the_timer->Ticker );
> - break;
> - case TIMER_INTERVAL_ON_TASK:
> - case TIMER_TIME_OF_DAY_ON_TASK:
> - timer_server = _Timer_server;
> - (*timer_server->cancel)( timer_server, the_timer );
> - break;
> - default:
> - _Assert( the_timer->the_class == TIMER_DORMANT );
> + ( *the_timer->routine )( the_timer->Object.id, the_timer->user_data );
> +}
> +
> +rtems_status_code _Timer_Fire(
> + rtems_id id,
> + rtems_interval interval,
> + rtems_timer_service_routine_entry routine,
> + void *user_data,
> + Timer_Classes the_class,
> + Watchdog_Service_routine_entry adaptor
> +)
> +{
> + Timer_Control *the_timer;
> + Objects_Locations location;
> + ISR_lock_Context lock_context;
> + Per_CPU_Control *cpu;
> +
> + the_timer = _Timer_Get( id, &location, &lock_context );
> + switch ( location ) {
> +
> + case OBJECTS_LOCAL:
> + cpu = _Timer_Acquire_critical( the_timer, &lock_context );
> + _Timer_Cancel( cpu, the_timer );
> + _Watchdog_Initialize( &the_timer->Ticker, adaptor );
> + the_timer->the_class = the_class;
> + the_timer->routine = routine;
> + the_timer->user_data = user_data;
> + the_timer->initial = interval;
> + the_timer->start_time = _Timer_Get_CPU_ticks( cpu );
> +
> + if ( _Timer_Is_interval_class( the_class ) ) {
> + _Watchdog_Insert(
> + &cpu->Watchdog.Header[ PER_CPU_WATCHDOG_RELATIVE ],
> + &the_timer->Ticker,
> + cpu->Watchdog.ticks + interval
> + );
> + } else {
> + _Watchdog_Insert(
> + &cpu->Watchdog.Header[ PER_CPU_WATCHDOG_ABSOLUTE ],
> + &the_timer->Ticker,
> + _Watchdog_Ticks_from_seconds( interval )
> + );
> + }
> +
> + _Timer_Release( cpu, &lock_context );
> + return RTEMS_SUCCESSFUL;
> +
> +#if defined(RTEMS_MULTIPROCESSING)
> + case OBJECTS_REMOTE: /* should never return this */
> +#endif
> + case OBJECTS_ERROR:
> break;
> }
>
> - _ISR_Enable( level );
> + return RTEMS_INVALID_ID;
> +}
> +
> +rtems_status_code _Timer_Fire_after(
> + rtems_id id,
> + rtems_interval ticks,
> + rtems_timer_service_routine_entry routine,
> + void *user_data,
> + Timer_Classes the_class,
> + Watchdog_Service_routine_entry adaptor
> +)
> +{
> + if ( ticks == 0 )
> + return RTEMS_INVALID_NUMBER;
> +
> + if ( !routine )
> + return RTEMS_INVALID_ADDRESS;
> +
> + return _Timer_Fire(
> + id,
> + ticks,
> + routine,
> + user_data,
> + the_class,
> + adaptor
> + );
> +}
> +
> +rtems_status_code _Timer_Fire_when(
> + rtems_id id,
> + const rtems_time_of_day *wall_time,
> + rtems_timer_service_routine_entry routine,
> + void *user_data,
> + Timer_Classes the_class,
> + Watchdog_Service_routine_entry adaptor
> +)
> +{
> + rtems_interval seconds;
> +
> + if ( !_TOD_Is_set() )
> + return RTEMS_NOT_DEFINED;
> +
> + if ( !routine )
> + return RTEMS_INVALID_ADDRESS;
> +
> + if ( !_TOD_Validate( wall_time ) )
> + return RTEMS_INVALID_CLOCK;
> +
> + seconds = _TOD_To_seconds( wall_time );
> + if ( seconds <= _TOD_Seconds_since_epoch() )
> + return RTEMS_INVALID_CLOCK;
> +
> + return _Timer_Fire(
> + id,
> + seconds,
> + routine,
> + user_data,
> + the_class,
> + adaptor
> + );
> +}
> +
> +void _Timer_Cancel( Per_CPU_Control *cpu, Timer_Control *the_timer )
> +{
> + Timer_Classes the_class;
> +
> + the_class = the_timer->the_class;
> +
> + if ( _Watchdog_Is_scheduled( &the_timer->Ticker ) ) {
> + the_timer->stop_time = _Timer_Get_CPU_ticks( cpu );
> + _Watchdog_Remove(
> + &cpu->Watchdog.Header[ _Timer_Watchdog_header_index( the_class ) ],
> + &the_timer->Ticker
> + );
> + } else if ( _Timer_Is_on_task_class( the_class ) ) {
> + Timer_server_Control *timer_server;
> + ISR_lock_Context lock_context;
> +
> + timer_server = _Timer_server;
> + _Assert( timer_server != NULL );
> + _Timer_server_Acquire_critical( timer_server, &lock_context );
> +
> + if ( _Watchdog_Get_state( &the_timer->Ticker ) == WATCHDOG_PENDING ) {
> + _Watchdog_Set_state( &the_timer->Ticker, WATCHDOG_INACTIVE );
> + _Chain_Extract_unprotected( &the_timer->Ticker.Node.Chain );
> + }
> +
> + _Timer_server_Release_critical( timer_server, &lock_context );
> + }
> }
>
> rtems_status_code rtems_timer_create(
> @@ -75,7 +208,7 @@ rtems_status_code rtems_timer_create(
> }
>
> the_timer->the_class = TIMER_DORMANT;
> - _Watchdog_Preinitialize( &the_timer->Ticker );
> + _Watchdog_Preinitialize( &the_timer->Ticker, _Per_CPU_Get_snapshot() );
>
> _Objects_Open(
> &_Timer_Information,
> diff --git a/cpukit/rtems/src/timerdelete.c
> b/cpukit/rtems/src/timerdelete.c
> index 0849ec5..9c41397 100644
> --- a/cpukit/rtems/src/timerdelete.c
> +++ b/cpukit/rtems/src/timerdelete.c
> @@ -18,12 +18,7 @@
> #include "config.h"
> #endif
>
> -#include <rtems/system.h>
> -#include <rtems/rtems/status.h>
> -#include <rtems/rtems/support.h>
> -#include <rtems/score/thread.h>
> #include <rtems/rtems/timerimpl.h>
> -#include <rtems/score/watchdogimpl.h>
>
> rtems_status_code rtems_timer_delete(
> rtems_id id
> @@ -31,15 +26,18 @@ rtems_status_code rtems_timer_delete(
> {
> Timer_Control *the_timer;
> Objects_Locations location;
> + ISR_lock_Context lock_context;
> + Per_CPU_Control *cpu;
>
> _Objects_Allocator_lock();
> - the_timer = _Timer_Get( id, &location );
> + the_timer = _Timer_Get( id, &location, &lock_context );
> switch ( location ) {
>
> case OBJECTS_LOCAL:
> _Objects_Close( &_Timer_Information, &the_timer->Object );
> - _Timer_Cancel( the_timer );
> - _Objects_Put( &the_timer->Object );
> + cpu = _Timer_Acquire_critical( the_timer, &lock_context );
> + _Timer_Cancel( cpu, the_timer );
> + _Timer_Release( cpu, &lock_context );
> _Timer_Free( the_timer );
> _Objects_Allocator_unlock();
> return RTEMS_SUCCESSFUL;
> diff --git a/cpukit/rtems/src/timerfireafter.c
> b/cpukit/rtems/src/timerfireafter.c
> index 84cf46b..82bd878 100644
> --- a/cpukit/rtems/src/timerfireafter.c
> +++ b/cpukit/rtems/src/timerfireafter.c
> @@ -18,12 +18,7 @@
> #include "config.h"
> #endif
>
> -#include <rtems/system.h>
> -#include <rtems/rtems/status.h>
> -#include <rtems/rtems/support.h>
> -#include <rtems/score/thread.h>
> #include <rtems/rtems/timerimpl.h>
> -#include <rtems/score/watchdogimpl.h>
>
> rtems_status_code rtems_timer_fire_after(
> rtems_id id,
> @@ -32,55 +27,12 @@ rtems_status_code rtems_timer_fire_after(
> void *user_data
> )
> {
> - Timer_Control *the_timer;
> - Objects_Locations location;
> - ISR_Level level;
> -
> - if ( ticks == 0 )
> - return RTEMS_INVALID_NUMBER;
> -
> - if ( !routine )
> - return RTEMS_INVALID_ADDRESS;
> -
> - the_timer = _Timer_Get( id, &location );
> - switch ( location ) {
> -
> - case OBJECTS_LOCAL:
> - _Timer_Cancel( the_timer );
> -
> - _ISR_Disable( level );
> -
> - /*
> - * Check to see if the watchdog has just been inserted by a
> - * higher priority interrupt. If so, abandon this insert.
> - */
> -
> - if ( the_timer->Ticker.state != WATCHDOG_INACTIVE ) {
> - _ISR_Enable( level );
> - _Objects_Put( &the_timer->Object );
> - return RTEMS_SUCCESSFUL;
> - }
> -
> - /*
> - * OK. Now we now the timer was not rescheduled by an interrupt
> - * so we can atomically initialize it as in use.
> - */
> -
> - the_timer->the_class = TIMER_INTERVAL;
> - _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data
> );
> - _ISR_Enable( level );
> -
> -
> - _Watchdog_Insert_ticks( &the_timer->Ticker, ticks );
> - _Objects_Put( &the_timer->Object );
> - return RTEMS_SUCCESSFUL;
> -
> -#if defined(RTEMS_MULTIPROCESSING)
> - case OBJECTS_REMOTE: /* should never return this */
> -#endif
> - case OBJECTS_ERROR:
> - break;
> - }
> -
> - return RTEMS_INVALID_ID;
> + return _Timer_Fire_after(
> + id,
> + ticks,
> + routine,
> + user_data,
> + TIMER_INTERVAL,
> + _Timer_Routine_adaptor
> + );
> }
> diff --git a/cpukit/rtems/src/timerfirewhen.c
> b/cpukit/rtems/src/timerfirewhen.c
> index 1acbaf9..eddeb16 100644
> --- a/cpukit/rtems/src/timerfirewhen.c
> +++ b/cpukit/rtems/src/timerfirewhen.c
> @@ -19,9 +19,6 @@
> #endif
>
> #include <rtems/rtems/timerimpl.h>
> -#include <rtems/rtems/clock.h>
> -#include <rtems/score/todimpl.h>
> -#include <rtems/score/watchdogimpl.h>
>
> rtems_status_code rtems_timer_fire_when(
> rtems_id id,
> @@ -30,43 +27,12 @@ rtems_status_code rtems_timer_fire_when(
> void *user_data
> )
> {
> - Timer_Control *the_timer;
> - Objects_Locations location;
> - rtems_interval seconds;
> -
> - if ( !_TOD_Is_set() )
> - return RTEMS_NOT_DEFINED;
> -
> - if ( !_TOD_Validate( wall_time ) )
> - return RTEMS_INVALID_CLOCK;
> -
> - if ( !routine )
> - return RTEMS_INVALID_ADDRESS;
> -
> - seconds = _TOD_To_seconds( wall_time );
> - if ( seconds <= _TOD_Seconds_since_epoch() )
> - return RTEMS_INVALID_CLOCK;
> -
> - the_timer = _Timer_Get( id, &location );
> - switch ( location ) {
> -
> - case OBJECTS_LOCAL:
> - _Timer_Cancel( the_timer );
> - the_timer->the_class = TIMER_TIME_OF_DAY;
> - _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
> - _Watchdog_Insert_seconds(
> - &the_timer->Ticker,
> - seconds - _TOD_Seconds_since_epoch()
> - );
> - _Objects_Put( &the_timer->Object );
> - return RTEMS_SUCCESSFUL;
> -
> -#if defined(RTEMS_MULTIPROCESSING)
> - case OBJECTS_REMOTE: /* should never return this */
> -#endif
> - case OBJECTS_ERROR:
> - break;
> - }
> -
> - return RTEMS_INVALID_ID;
> + return _Timer_Fire_when(
> + id,
> + wall_time,
> + routine,
> + user_data,
> + TIMER_TIME_OF_DAY,
> + _Timer_Routine_adaptor
> + );
> }
> diff --git a/cpukit/rtems/src/timergetinfo.c
> b/cpukit/rtems/src/timergetinfo.c
> index 17c32e6..a11861c 100644
> --- a/cpukit/rtems/src/timergetinfo.c
> +++ b/cpukit/rtems/src/timergetinfo.c
> @@ -32,19 +32,22 @@ rtems_status_code rtems_timer_get_information(
> {
> Timer_Control *the_timer;
> Objects_Locations location;
> + ISR_lock_Context lock_context;
> + Per_CPU_Control *cpu;
>
> if ( !the_info )
> return RTEMS_INVALID_ADDRESS;
>
> - the_timer = _Timer_Get( id, &location );
> + the_timer = _Timer_Get( id, &location, &lock_context );
> switch ( location ) {
>
> case OBJECTS_LOCAL:
> + cpu = _Timer_Acquire_critical( the_timer, &lock_context );
> the_info->the_class = the_timer->the_class;
> - the_info->initial = the_timer->Ticker.initial;
> - the_info->start_time = the_timer->Ticker.start_time;
> - the_info->stop_time = the_timer->Ticker.stop_time;
> - _Objects_Put( &the_timer->Object );
> + the_info->initial = the_timer->initial;
> + the_info->start_time = the_timer->start_time;
> + the_info->stop_time = the_timer->stop_time;
> + _Timer_Release( cpu, &lock_context );
> return RTEMS_SUCCESSFUL;
>
> #if defined(RTEMS_MULTIPROCESSING)
> diff --git a/cpukit/rtems/src/timerreset.c b/cpukit/rtems/src/timerreset.c
> index 7ab172e..72c912b 100644
> --- a/cpukit/rtems/src/timerreset.c
> +++ b/cpukit/rtems/src/timerreset.c
> @@ -44,40 +44,29 @@ rtems_status_code rtems_timer_reset(
> {
> Timer_Control *the_timer;
> Objects_Locations location;
> - rtems_status_code status = RTEMS_SUCCESSFUL;
> + ISR_lock_Context lock_context;
> + Per_CPU_Control *cpu;
> + rtems_status_code status;
>
> - the_timer = _Timer_Get( id, &location );
> + the_timer = _Timer_Get( id, &location, &lock_context );
> switch ( location ) {
>
> case OBJECTS_LOCAL:
> - if ( the_timer->the_class == TIMER_INTERVAL ) {
> - _Watchdog_Reset_ticks( &the_timer->Ticker );
> - } else if ( the_timer->the_class == TIMER_INTERVAL_ON_TASK ) {
> - Timer_server_Control *timer_server = _Timer_server;
> + cpu = _Timer_Acquire_critical( the_timer, &lock_context );
>
> - /*
> - * There is no way for a timer to have this class unless
> - * it was scheduled as a server fire. That requires that
> - * the Timer Server be initiated. So this error cannot
> - * occur unless something is internally wrong.
> - */
> - #if defined(RTEMS_DEBUG)
> - if ( !timer_server ) {
> - _Objects_Put( &the_timer->Object );
> - return RTEMS_INCORRECT_STATE;
> - }
> - #endif
> - (*timer_server->cancel)( timer_server, the_timer );
> - (*timer_server->schedule_operation)( timer_server, the_timer );
> + if ( _Timer_Is_interval_class( the_timer->the_class ) ) {
> + _Timer_Cancel( cpu, the_timer );
> + _Watchdog_Insert(
> + &cpu->Watchdog.Header[ PER_CPU_WATCHDOG_RELATIVE ],
> + &the_timer->Ticker,
> + cpu->Watchdog.ticks + the_timer->initial
> + );
> + status = RTEMS_SUCCESSFUL;
> } else {
> - /*
> - * Must be dormant or time of day timer (e.g. TIMER_DORMANT,
> - * TIMER_TIME_OF_DAY, or TIMER_TIME_OF_DAY_ON_TASK). We
> - * can only reset active interval timers.
> - */
> status = RTEMS_NOT_DEFINED;
> }
> - _Objects_Put( &the_timer->Object );
> +
> + _Timer_Release( cpu, &lock_context );
> return status;
>
> #if defined(RTEMS_MULTIPROCESSING)
> diff --git a/cpukit/rtems/src/timerserver.c
> b/cpukit/rtems/src/timerserver.c
> index 7d75780..cf06319 100644
> --- a/cpukit/rtems/src/timerserver.c
> +++ b/cpukit/rtems/src/timerserver.c
> @@ -15,7 +15,7 @@
> /* COPYRIGHT (c) 1989-2008.
> * On-Line Applications Research Corporation (OAR).
> *
> - * Copyright (c) 2009-2015 embedded brains GmbH.
> + * Copyright (c) 2009, 2016 embedded brains GmbH.
> *
> * The license and distribution terms for this file may be
> * found in the file LICENSE in this distribution or at
> @@ -34,193 +34,48 @@
>
> static Timer_server_Control _Timer_server_Default;
>
> -static void _Timer_server_Cancel_method(
> +static void _Timer_server_Acquire(
> Timer_server_Control *ts,
> - Timer_Control *timer
> + ISR_lock_Context *lock_context
> )
> {
> - if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
> - _Watchdog_Remove( &ts->Interval_watchdogs.Header, &timer->Ticker );
> - } else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
> - _Watchdog_Remove( &ts->TOD_watchdogs.Header, &timer->Ticker );
> - }
> -}
> -
> -static Watchdog_Interval _Timer_server_Get_ticks( void )
> -{
> - return _Watchdog_Ticks_since_boot;
> + _ISR_lock_ISR_disable_and_acquire( &ts->Lock, lock_context );
> }
>
> -static Watchdog_Interval _Timer_server_Get_seconds( void )
> -{
> - return _TOD_Seconds_since_epoch();
> -}
> -
> -static void _Timer_server_Update_system_watchdog(
> - Timer_server_Watchdogs *watchdogs,
> - Watchdog_Header *system_header
> -)
> -{
> - ISR_lock_Context lock_context;
> -
> - _Watchdog_Acquire( &watchdogs->Header, &lock_context );
> -
> - if ( watchdogs->system_watchdog_helper == NULL ) {
> - Thread_Control *executing;
> - uint32_t my_generation;
> -
> - executing = _Thread_Executing;
> - watchdogs->system_watchdog_helper = executing;
> -
> - do {
> - my_generation = watchdogs->generation;
> -
> - if ( !_Watchdog_Is_empty( &watchdogs->Header ) ) {
> - Watchdog_Control *first;
> - Watchdog_Interval delta;
> -
> - first = _Watchdog_First( &watchdogs->Header );
> - delta = first->delta_interval;
> -
> - if (
> - watchdogs->System_watchdog.state == WATCHDOG_INACTIVE
> - || delta != watchdogs->system_watchdog_delta
> - ) {
> - watchdogs->system_watchdog_delta = delta;
> - _Watchdog_Release( &watchdogs->Header, &lock_context );
> -
> - _Watchdog_Remove( system_header, &watchdogs->System_watchdog );
> - watchdogs->System_watchdog.initial = delta;
> - _Watchdog_Insert( system_header, &watchdogs->System_watchdog );
> -
> - _Watchdog_Acquire( &watchdogs->Header, &lock_context );
> - }
> - }
> - } while ( watchdogs->generation != my_generation );
> -
> - watchdogs->system_watchdog_helper = NULL;
> - }
> -
> - _Watchdog_Release( &watchdogs->Header, &lock_context );
> -}
> -
> -static void _Timer_server_Insert_timer(
> - Timer_server_Watchdogs *watchdogs,
> - Timer_Control *timer,
> - Watchdog_Header *system_header,
> - Watchdog_Interval (*get_ticks)( void )
> -)
> -{
> - ISR_lock_Context lock_context;
> - Watchdog_Interval now;
> - Watchdog_Interval delta;
> -
> - _Watchdog_Acquire( &watchdogs->Header, &lock_context );
> -
> - now = (*get_ticks)();
> - delta = now - watchdogs->last_snapshot;
> - watchdogs->last_snapshot = now;
> - watchdogs->current_snapshot = now;
> -
> - if ( watchdogs->system_watchdog_delta > delta ) {
> - watchdogs->system_watchdog_delta -= delta;
> - } else {
> - watchdogs->system_watchdog_delta = 0;
> - }
> -
> - if ( !_Watchdog_Is_empty( &watchdogs->Header ) ) {
> - Watchdog_Control *first = _Watchdog_First( &watchdogs->Header );
> -
> - if ( first->delta_interval > delta ) {
> - first->delta_interval -= delta;
> - } else {
> - first->delta_interval = 0;
> - }
> - }
> -
> - _Watchdog_Insert_locked(
> - &watchdogs->Header,
> - &timer->Ticker,
> - &lock_context
> - );
> -
> - ++watchdogs->generation;
> -
> - _Watchdog_Release( &watchdogs->Header, &lock_context );
> -
> - _Timer_server_Update_system_watchdog( watchdogs, system_header );
> -}
> -
> -static void _Timer_server_Schedule_operation_method(
> +static void _Timer_server_Release(
> Timer_server_Control *ts,
> - Timer_Control *timer
> + ISR_lock_Context *lock_context
> )
> {
> - if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
> - _Timer_server_Insert_timer(
> - &ts->Interval_watchdogs,
> - timer,
> - &_Watchdog_Ticks_header,
> - _Timer_server_Get_ticks
> - );
> - } else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
> - _Timer_server_Insert_timer(
> - &ts->TOD_watchdogs,
> - timer,
> - &_Watchdog_Seconds_header,
> - _Timer_server_Get_seconds
> - );
> - }
> + _ISR_lock_Release_and_ISR_enable( &ts->Lock, lock_context );
> }
>
> -static void _Timer_server_Update_current_snapshot(
> - Timer_server_Watchdogs *watchdogs,
> - Watchdog_Interval (*get_ticks)( void )
> -)
> +void _Timer_server_Routine_adaptor( Watchdog_Control *the_watchdog )
> {
> - ISR_lock_Context lock_context;
> + Timer_Control *the_timer;
> + ISR_lock_Context lock_context;
> + Per_CPU_Control *cpu;
> + Timer_server_Control *ts;
> + bool wakeup;
>
> - _Watchdog_Acquire( &watchdogs->Header, &lock_context );
> - watchdogs->current_snapshot = (*get_ticks)();
> - watchdogs->system_watchdog_delta = 0;
> - _Watchdog_Release( &watchdogs->Header, &lock_context );
> -}
> + ts = _Timer_server;
> + _Assert( ts != NULL );
> + the_timer = RTEMS_CONTAINER_OF( the_watchdog, Timer_Control, Ticker );
>
> -static void _Timer_server_Tickle(
> - Timer_server_Watchdogs *watchdogs,
> - Watchdog_Header *system_header,
> - Watchdog_Interval (*get_ticks)( void ),
> - bool ticks
> -)
> -{
> - ISR_lock_Context lock_context;
> - Watchdog_Interval now;
> - Watchdog_Interval last;
> + _Timer_server_Acquire( ts, &lock_context );
>
> - _Watchdog_Acquire( &watchdogs->Header, &lock_context );
> + _Assert( _Watchdog_Get_state( &the_timer->Ticker ) == WATCHDOG_INACTIVE
> );
> + _Watchdog_Set_state( &the_timer->Ticker, WATCHDOG_PENDING );
> + cpu = _Watchdog_Get_CPU( &the_timer->Ticker );
> + the_timer->stop_time = _Timer_Get_CPU_ticks( cpu );
> + wakeup = _Chain_Is_empty( &ts->Pending );
> + _Chain_Append_unprotected( &ts->Pending, &the_timer->Ticker.Node.Chain
> );
>
> - now = watchdogs->current_snapshot;
> - last = watchdogs->last_snapshot;
> - watchdogs->last_snapshot = now;
> + _Timer_server_Release( ts, &lock_context );
>
> - if ( ticks || now >= last ) {
> - _Watchdog_Adjust_forward_locked(
> - &watchdogs->Header,
> - now - last,
> - &lock_context
> - );
> - } else {
> - _Watchdog_Adjust_backward_locked(
> - &watchdogs->Header,
> - last - now
> - );
> + if ( wakeup ) {
> + (void) rtems_event_system_send( ts->server_id,
> RTEMS_EVENT_SYSTEM_SERVER );
> }
> -
> - ++watchdogs->generation;
> -
> - _Watchdog_Release( &watchdogs->Header, &lock_context );
> -
> - _Timer_server_Update_system_watchdog( watchdogs, system_header );
> }
>
> /**
> @@ -239,21 +94,38 @@ static rtems_task _Timer_server_Body(
> Timer_server_Control *ts = (Timer_server_Control *) arg;
>
> while ( true ) {
> - rtems_event_set events;
> + ISR_lock_Context lock_context;
> + rtems_event_set events;
>
> - _Timer_server_Tickle(
> - &ts->Interval_watchdogs,
> - &_Watchdog_Ticks_header,
> - _Timer_server_Get_ticks,
> - true
> - );
> + _Timer_server_Acquire( ts, &lock_context );
>
> - _Timer_server_Tickle(
> - &ts->TOD_watchdogs,
> - &_Watchdog_Seconds_header,
> - _Timer_server_Get_seconds,
> - false
> - );
> + while ( true ) {
> + Watchdog_Control *the_watchdog;
> + Timer_Control *the_timer;
> + rtems_timer_service_routine_entry routine;
> + Objects_Id id;
> + void *user_data;
> +
> + the_watchdog = (Watchdog_Control *) _Chain_Get_unprotected(
> &ts->Pending );
> + if ( the_watchdog == NULL ) {
> + break;
> + }
> +
> + _Assert( _Watchdog_Get_state( the_watchdog ) == WATCHDOG_PENDING );
> + _Watchdog_Set_state( the_watchdog, WATCHDOG_INACTIVE );
> + the_timer = RTEMS_CONTAINER_OF( the_watchdog, Timer_Control, Ticker
> );
> + routine = the_timer->routine;
> + id = the_timer->Object.id;
> + user_data = the_timer->user_data;
> +
> + _Timer_server_Release( ts, &lock_context );
> +
> + ( *routine )( id, user_data );
> +
> + _Timer_server_Acquire( ts, &lock_context );
> + }
> +
> + _Timer_server_Release( ts, &lock_context );
>
> (void) rtems_event_system_receive(
> RTEMS_EVENT_SYSTEM_SERVER,
> @@ -264,99 +136,35 @@ static rtems_task _Timer_server_Body(
> }
> }
>
> -static void _Timer_server_Wakeup(
> - Objects_Id id,
> - void *arg
> -)
> -{
> - Timer_server_Control *ts = arg;
> -
> - _Timer_server_Update_current_snapshot(
> - &ts->Interval_watchdogs,
> - _Timer_server_Get_ticks
> - );
> -
> - _Timer_server_Update_current_snapshot(
> - &ts->TOD_watchdogs,
> - _Timer_server_Get_seconds
> - );
> -
> - (void) rtems_event_system_send( id, RTEMS_EVENT_SYSTEM_SERVER );
> -}
> -
> -static void _Timer_server_Initialize_watchdogs(
> - Timer_server_Control *ts,
> - rtems_id id,
> - Timer_server_Watchdogs *watchdogs,
> - Watchdog_Interval (*get_ticks)( void )
> -)
> -{
> - Watchdog_Interval now;
> -
> - now = (*get_ticks)();
> - watchdogs->last_snapshot = now;
> - watchdogs->current_snapshot = now;
> -
> - _Watchdog_Header_initialize( &watchdogs->Header );
> - _Watchdog_Preinitialize( &watchdogs->System_watchdog );
> - _Watchdog_Initialize(
> - &watchdogs->System_watchdog,
> - _Timer_server_Wakeup,
> - id,
> - ts
> - );
> -}
> -
> -/**
> - * @brief rtems_timer_initiate_server
> - *
> - * This directive creates and starts the server for task-based timers.
> - * It must be invoked before any task-based timers can be initiated.
> - *
> - * @param[in] priority is the timer server priority
> - * @param[in] stack_size is the stack size in bytes
> - * @param[in] attribute_set is the timer server attributes
> - *
> - * @return This method returns RTEMS_SUCCESSFUL if successful and an
> - * error code otherwise.
> - */
> -rtems_status_code rtems_timer_initiate_server(
> - uint32_t priority,
> - uint32_t stack_size,
> - rtems_attribute attribute_set
> +static rtems_status_code _Timer_server_Initiate(
> + rtems_task_priority priority,
> + size_t stack_size,
> + rtems_attribute attribute_set
> )
> {
> - rtems_id id;
> rtems_status_code status;
> - rtems_task_priority _priority;
> - static bool initialized = false;
> - bool tmpInitialized;
> - Timer_server_Control *ts = &_Timer_server_Default;
> + rtems_id id;
> + Timer_server_Control *ts;
> +
> + /*
> + * Just to make sure this is only called once.
> + */
> + if ( _Timer_server != NULL ) {
> + return RTEMS_INCORRECT_STATE;
> + }
>
> /*
> * Make sure the requested priority is valid. The if is
> * structured so we check it is invalid before looking for
> * a specific invalid value as the default.
> */
> - _priority = priority;
> if ( !_RTEMS_tasks_Priority_is_valid( priority ) ) {
> if ( priority != RTEMS_TIMER_SERVER_DEFAULT_PRIORITY )
> return RTEMS_INVALID_PRIORITY;
> - _priority = PRIORITY_PSEUDO_ISR;
> + priority = PRIORITY_PSEUDO_ISR;
> }
>
> /*
> - * Just to make sure this is only called once.
> - */
> - _Once_Lock();
> - tmpInitialized = initialized;
> - initialized = true;
> - _Once_Unlock();
> -
> - if ( tmpInitialized )
> - return RTEMS_INCORRECT_STATE;
> -
> - /*
> * Create the Timer Server with the name the name of "TIME". The
> attribute
> * RTEMS_SYSTEM_TASK allows us to set a priority to 0 which will makes
> it
> * higher than any other task in the system. It can be viewed as a low
> @@ -371,19 +179,18 @@ rtems_status_code rtems_timer_initiate_server(
> * GNAT run-time is violated.
> */
> status = rtems_task_create(
> - _Objects_Build_name('T','I','M','E'), /* "TIME" */
> - _priority, /* create with priority 1 since 0 is illegal */
> - stack_size, /* let user specify stack size */
> + rtems_build_name('T','I','M','E'),
> + priority,
> + stack_size,
> rtems_configuration_is_smp_enabled() ?
> RTEMS_DEFAULT_MODES : /* no preempt is not supported for SMP */
> RTEMS_NO_PREEMPT, /* no preempt is like an interrupt */
> /* user may want floating point but we need */
> /* system task specified for 0 priority */
> attribute_set | RTEMS_SYSTEM_TASK,
> - &id /* get the id back */
> + &id
> );
> - if (status) {
> - initialized = false;
> + if (status != RTEMS_SUCCESSFUL) {
> return status;
> }
>
> @@ -392,26 +199,10 @@ rtems_status_code rtems_timer_initiate_server(
> * Timer Server so we do not have to have a critical section.
> */
>
> - _Timer_server_Initialize_watchdogs(
> - ts,
> - id,
> - &ts->Interval_watchdogs,
> - _Timer_server_Get_ticks
> - );
> -
> - _Timer_server_Initialize_watchdogs(
> - ts,
> - id,
> - &ts->TOD_watchdogs,
> - _Timer_server_Get_seconds
> - );
> -
> - /*
> - * Initialize the pointer to the timer server methods so applications
> that
> - * do not use the Timer Server do not have to pull it in.
> - */
> - ts->cancel = _Timer_server_Cancel_method;
> - ts->schedule_operation = _Timer_server_Schedule_operation_method;
> + ts = &_Timer_server_Default;
> + _ISR_lock_Initialize( &ts->Lock, "Timer Server" );
> + _Chain_Initialize_empty( &ts->Pending );
> + ts->server_id = id;
>
> /*
> * The default timer server is now available.
> @@ -426,19 +217,22 @@ rtems_status_code rtems_timer_initiate_server(
> _Timer_server_Body,
> (rtems_task_argument) ts
> );
> + _Assert( status == RTEMS_SUCCESSFUL );
>
> - #if defined(RTEMS_DEBUG)
> - /*
> - * One would expect a call to rtems_task_delete() here to clean up
> - * but there is actually no way (in normal circumstances) that the
> - * start can fail. The id and starting address are known to be
> - * be good. If this service fails, something is weirdly wrong on the
> - * target such as a stray write in an ISR or incorrect memory layout.
> - */
> - if (status) {
> - initialized = false;
> - }
> - #endif
> + return status;
> +}
> +
> +rtems_status_code rtems_timer_initiate_server(
> + rtems_task_priority priority,
> + size_t stack_size,
> + rtems_attribute attribute_set
> +)
> +{
> + rtems_status_code status;
> +
> + _Once_Lock();
> + status = _Timer_server_Initiate( priority, stack_size, attribute_set );
> + _Once_Unlock();
>
> return status;
> }
> diff --git a/cpukit/rtems/src/timerserverfireafter.c
> b/cpukit/rtems/src/timerserverfireafter.c
> index 0636782..ce1fd05 100644
> --- a/cpukit/rtems/src/timerserverfireafter.c
> +++ b/cpukit/rtems/src/timerserverfireafter.c
> @@ -18,12 +18,7 @@
> #include "config.h"
> #endif
>
> -#include <rtems/system.h>
> -#include <rtems/rtems/status.h>
> -#include <rtems/rtems/support.h>
> -#include <rtems/score/thread.h>
> #include <rtems/rtems/timerimpl.h>
> -#include <rtems/score/watchdogimpl.h>
>
> rtems_status_code rtems_timer_server_fire_after(
> rtems_id id,
> @@ -32,60 +27,19 @@ rtems_status_code rtems_timer_server_fire_after(
> void *user_data
> )
> {
> - Timer_Control *the_timer;
> - Objects_Locations location;
> - ISR_Level level;
> - Timer_server_Control *timer_server = _Timer_server;
> + Timer_server_Control *timer_server;
> +
> + timer_server = _Timer_server;
>
> if ( !timer_server )
> return RTEMS_INCORRECT_STATE;
>
> - if ( !routine )
> - return RTEMS_INVALID_ADDRESS;
> -
> - if ( ticks == 0 )
> - return RTEMS_INVALID_NUMBER;
> -
> - the_timer = _Timer_Get( id, &location );
> - switch ( location ) {
> -
> - case OBJECTS_LOCAL:
> - _Timer_Cancel( the_timer );
> -
> - _ISR_Disable( level );
> -
> - /*
> - * Check to see if the watchdog has just been inserted by a
> - * higher priority interrupt. If so, abandon this insert.
> - */
> -
> - if ( the_timer->Ticker.state != WATCHDOG_INACTIVE ) {
> - _ISR_Enable( level );
> - _Objects_Put( &the_timer->Object );
> - return RTEMS_SUCCESSFUL;
> - }
> -
> - /*
> - * OK. Now we now the timer was not rescheduled by an interrupt
> - * so we can atomically initialize it as in use.
> - */
> -
> - the_timer->the_class = TIMER_INTERVAL_ON_TASK;
> - _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data
> );
> - the_timer->Ticker.initial = ticks;
> - _ISR_Enable( level );
> -
> - (*timer_server->schedule_operation)( timer_server, the_timer );
> -
> - _Objects_Put( &the_timer->Object );
> - return RTEMS_SUCCESSFUL;
> -
> -#if defined(RTEMS_MULTIPROCESSING)
> - case OBJECTS_REMOTE: /* should never return this */
> -#endif
> - case OBJECTS_ERROR:
> - break;
> - }
> -
> - return RTEMS_INVALID_ID;
> + return _Timer_Fire_after(
> + id,
> + ticks,
> + routine,
> + user_data,
> + TIMER_INTERVAL_ON_TASK,
> + _Timer_server_Routine_adaptor
> + );
> }
> diff --git a/cpukit/rtems/src/timerserverfirewhen.c
> b/cpukit/rtems/src/timerserverfirewhen.c
> index 0069af1..f96a470 100644
> --- a/cpukit/rtems/src/timerserverfirewhen.c
> +++ b/cpukit/rtems/src/timerserverfirewhen.c
> @@ -19,26 +19,6 @@
> #endif
>
> #include <rtems/rtems/timerimpl.h>
> -#include <rtems/rtems/clock.h>
> -#include <rtems/score/todimpl.h>
> -#include <rtems/score/watchdogimpl.h>
> -
> -/*
> - * rtems_timer_server_fire_when
> - *
> - * This directive allows a thread to start a timer which will by
> - * executed by the Timer Server when it fires.
> - *
> - * Input parameters:
> - * id - timer id
> - * wall_time - time of day to fire timer
> - * routine - routine to schedule
> - * user_data - passed as argument to routine when it is fired
> - *
> - * Output parameters:
> - * RTEMS_SUCCESSFUL - if successful
> - * error code - if unsuccessful
> - */
>
> rtems_status_code rtems_timer_server_fire_when(
> rtems_id id,
> @@ -47,47 +27,19 @@ rtems_status_code rtems_timer_server_fire_when(
> void *user_data
> )
> {
> - Timer_Control *the_timer;
> - Objects_Locations location;
> - rtems_interval seconds;
> - Timer_server_Control *timer_server = _Timer_server;
> + Timer_server_Control *timer_server;
> +
> + timer_server = _Timer_server;
>
> if ( !timer_server )
> return RTEMS_INCORRECT_STATE;
>
> - if ( !_TOD_Is_set() )
> - return RTEMS_NOT_DEFINED;
> -
> - if ( !routine )
> - return RTEMS_INVALID_ADDRESS;
> -
> - if ( !_TOD_Validate( wall_time ) )
> - return RTEMS_INVALID_CLOCK;
> -
> - seconds = _TOD_To_seconds( wall_time );
> - if ( seconds <= _TOD_Seconds_since_epoch() )
> - return RTEMS_INVALID_CLOCK;
> -
> - the_timer = _Timer_Get( id, &location );
> - switch ( location ) {
> -
> - case OBJECTS_LOCAL:
> - _Timer_Cancel( the_timer );
> - the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK;
> - _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
> - the_timer->Ticker.initial = seconds - _TOD_Seconds_since_epoch();
> -
> - (*timer_server->schedule_operation)( timer_server, the_timer );
> -
> - _Objects_Put( &the_timer->Object );
> - return RTEMS_SUCCESSFUL;
> -
> -#if defined(RTEMS_MULTIPROCESSING)
> - case OBJECTS_REMOTE: /* should never return this */
> -#endif
> - case OBJECTS_ERROR:
> - break;
> - }
> -
> - return RTEMS_INVALID_ID;
> + return _Timer_Fire_when(
> + id,
> + wall_time,
> + routine,
> + user_data,
> + TIMER_TIME_OF_DAY_ON_TASK,
> + _Timer_server_Routine_adaptor
> + );
> }
> diff --git a/cpukit/sapi/src/exinit.c b/cpukit/sapi/src/exinit.c
> index 7df2316..350c774 100644
> --- a/cpukit/sapi/src/exinit.c
> +++ b/cpukit/sapi/src/exinit.c
> @@ -38,7 +38,6 @@
> #include <rtems/score/timecounter.h>
> #include <rtems/score/threadimpl.h>
> #include <rtems/score/todimpl.h>
> -#include <rtems/score/watchdogimpl.h>
> #include <rtems/score/wkspace.h>
>
> const char _Copyright_Notice[] =
> @@ -87,8 +86,6 @@ static void rtems_initialize_data_structures(void)
> _API_Mutex_Allocate( &_RTEMS_Allocator_Mutex );
> _API_Mutex_Allocate( &_Once_Mutex );
>
> - _Watchdog_Handler_initialization();
> -
> _Thread_Handler_initialization();
>
> _Scheduler_Handler_initialization();
> diff --git a/cpukit/score/Makefile.am b/cpukit/score/Makefile.am
> index 3d3f1c1..ea440b3 100644
> --- a/cpukit/score/Makefile.am
> +++ b/cpukit/score/Makefile.am
> @@ -327,14 +327,13 @@ libscore_a_SOURCES += src/timespecaddto.c
> src/timespecfromticks.c \
>
> ## TOD_C_FILES
> libscore_a_SOURCES += src/coretod.c src/coretodset.c \
> - src/coretodtickle.c \
> src/coretodtickspersec.c \
> src/coretodadjust.c
> libscore_a_SOURCES += src/coretodabsolutetimeout.c
>
> ## WATCHDOG_C_FILES
> -libscore_a_SOURCES += src/watchdog.c src/watchdogadjust.c \
> - src/watchdoginsert.c src/watchdogremove.c
> +libscore_a_SOURCES += src/watchdoginsert.c
> +libscore_a_SOURCES += src/watchdogremove.c
> libscore_a_SOURCES += src/watchdogtick.c
> libscore_a_SOURCES += src/watchdogtickssinceboot.c
>
> diff --git a/cpukit/score/include/rtems/score/mrsp.h
> b/cpukit/score/include/rtems/score/mrsp.h
> index 08f96ac..cb3de67 100644
> --- a/cpukit/score/include/rtems/score/mrsp.h
> +++ b/cpukit/score/include/rtems/score/mrsp.h
> @@ -1,5 +1,5 @@
> /*
> - * Copyright (c) 2014 embedded brains GmbH. All rights reserved.
> + * Copyright (c) 2014, 2016 embedded brains GmbH. All rights reserved.
> *
> * embedded brains GmbH
> * Dornierstr. 4
> @@ -128,6 +128,11 @@ typedef struct {
> * MRSP_TIMEOUT. State changes are protected by the MrsP control lock.
> */
> volatile MRSP_Status status;
> +
> + /**
> + * @brief Watchdog for timeouts.
> + */
> + Watchdog_Control Watchdog;
> } MRSP_Rival;
>
> /**
> diff --git a/cpukit/score/include/rtems/score/mrspimpl.h
> b/cpukit/score/include/rtems/score/mrspimpl.h
> index bc9ed4b..7638fb5 100644
> --- a/cpukit/score/include/rtems/score/mrspimpl.h
> +++ b/cpukit/score/include/rtems/score/mrspimpl.h
> @@ -1,5 +1,5 @@
> /*
> - * Copyright (c) 2014-2015 embedded brains GmbH. All rights reserved.
> + * Copyright (c) 2014, 2016 embedded brains GmbH. All rights reserved.
> *
> * embedded brains GmbH
> * Dornierstr. 4
> @@ -159,18 +159,13 @@ RTEMS_INLINE_ROUTINE void _MRSP_Set_ceiling_priority(
> mrsp->ceiling_priorities[ scheduler_index ] = ceiling_priority;
> }
>
> -RTEMS_INLINE_ROUTINE void _MRSP_Timeout(
> - Objects_Id id,
> - void *arg
> -)
> +RTEMS_INLINE_ROUTINE void _MRSP_Timeout( Watchdog_Control *watchdog )
> {
> - MRSP_Rival *rival = arg;
> + MRSP_Rival *rival = RTEMS_CONTAINER_OF( watchdog, MRSP_Rival, Watchdog
> );
> MRSP_Control *mrsp = rival->resource;
> Thread_Control *thread = rival->thread;
> ISR_lock_Context lock_context;
>
> - (void) id;
> -
> _ISR_lock_ISR_disable_and_acquire( &mrsp->Lock, &lock_context );
>
> if ( rival->status == MRSP_WAIT_FOR_OWNERSHIP ) {
> @@ -209,6 +204,7 @@ RTEMS_INLINE_ROUTINE MRSP_Status
> _MRSP_Wait_for_ownership(
> bool initial_life_protection;
> Per_CPU_Control *cpu_self;
> ISR_lock_Context giant_lock_context;
> + ISR_Level level;
>
> rival.thread = executing;
> rival.resource = mrsp;
> @@ -236,13 +232,11 @@ RTEMS_INLINE_ROUTINE MRSP_Status
> _MRSP_Wait_for_ownership(
> _Thread_Raise_priority( executing, ceiling_priority );
>
> if ( timeout > 0 ) {
> - _Watchdog_Initialize(
> - &executing->Timer,
> - _MRSP_Timeout,
> - 0,
> - &rival
> - );
> - _Watchdog_Insert_ticks( &executing->Timer, timeout );
> + _Watchdog_Preinitialize( &rival.Watchdog, cpu_self );
> + _Watchdog_Initialize( &rival.Watchdog, _MRSP_Timeout );
> + _ISR_Disable_without_giant( level );
> + _Watchdog_Per_CPU_insert_relative( &rival.Watchdog, cpu_self, timeout
> );
> + _ISR_Enable_without_giant( level );
> }
>
> initial_life_protection = _Thread_Set_life_protection( true );
> @@ -258,7 +252,13 @@ RTEMS_INLINE_ROUTINE MRSP_Status
> _MRSP_Wait_for_ownership(
> _Thread_Set_life_protection( initial_life_protection );
>
> if ( timeout > 0 ) {
> - _Watchdog_Remove_ticks( &executing->Timer );
> + _ISR_Disable_without_giant( level );
> + _Watchdog_Per_CPU_remove(
> + &rival.Watchdog,
> + cpu_self,
> + &cpu_self->Watchdog.Header[ PER_CPU_WATCHDOG_RELATIVE ]
> + );
> + _ISR_Enable_without_giant( level );
>
> if ( status == MRSP_TIMEOUT ) {
> _MRSP_Restore_priority( executing, initial_priority );
> diff --git a/cpukit/score/include/rtems/score/percpu.h
> b/cpukit/score/include/rtems/score/percpu.h
> index 39be1e3..2201788 100644
> --- a/cpukit/score/include/rtems/score/percpu.h
> +++ b/cpukit/score/include/rtems/score/percpu.h
> @@ -23,10 +23,11 @@
> #include <rtems/asm.h>
> #else
> #include <rtems/score/assert.h>
> - #include <rtems/score/isrlevel.h>
> + #include <rtems/score/isrlock.h>
> #include <rtems/score/smp.h>
> #include <rtems/score/smplock.h>
> #include <rtems/score/timestamp.h>
> + #include <rtems/score/watchdog.h>
> #endif
>
> #ifdef __cplusplus
> @@ -41,7 +42,7 @@ extern "C" {
> * processor.
> */
> #if defined( RTEMS_PROFILING )
> - #define PER_CPU_CONTROL_SIZE_LOG2 8
> + #define PER_CPU_CONTROL_SIZE_LOG2 9
> #else
> #define PER_CPU_CONTROL_SIZE_LOG2 7
> #endif
> @@ -226,6 +227,32 @@ typedef struct {
> } Per_CPU_Stats;
>
> /**
> + * @brief Per-CPU watchdog header index.
> + */
> +typedef enum {
> + /**
> + * @brief Index for relative per-CPU watchdog header.
> + *
> + * The reference time point for this header is current ticks value
> + * during insert. Time is measured in clock ticks.
> + */
> + PER_CPU_WATCHDOG_RELATIVE,
> +
> + /**
> + * @brief Index for absolute per-CPU watchdog header.
> + *
> + * The reference time point for this header is the POSIX Epoch. Time is
> + * measured in nanoseconds since POSIX Epoch.
> + */
> + PER_CPU_WATCHDOG_ABSOLUTE,
> +
> + /**
> + * @brief Count of per-CPU watchdog headers.
> + */
> + PER_CPU_WATCHDOG_COUNT
> +} Per_CPU_Watchdog_index;
> +
> +/**
> * @brief Per CPU Core Structure
> *
> * This structure is used to hold per core state information.
> @@ -309,6 +336,28 @@ typedef struct Per_CPU_Control {
> /** This is the time of the last context switch on this CPU. */
> Timestamp_Control time_of_last_context_switch;
>
> + /**
> + * @brief Watchdog state for this processor.
> + */
> + struct {
> + /**
> + * @brief Protects all watchdog operations on this processor.
> + */
> + ISR_LOCK_MEMBER( Lock )
> +
> + /**
> + * @brief Watchdog ticks on this processor used for relative
> watchdogs.
> + */
> + uint64_t ticks;
> +
> + /**
> + * @brief Header for watchdogs.
> + *
> + * @see Per_CPU_Watchdog_index.
> + */
> + Watchdog_Header Header[ PER_CPU_WATCHDOG_COUNT ];
> + } Watchdog;
> +
> #if defined( RTEMS_SMP )
> /**
> * @brief This lock protects some parts of the low-level thread
> dispatching.
> diff --git a/cpukit/score/include/rtems/score/schedulerimpl.h
> b/cpukit/score/include/rtems/score/schedulerimpl.h
> index cadebfd..d50c36a 100644
> --- a/cpukit/score/include/rtems/score/schedulerimpl.h
> +++ b/cpukit/score/include/rtems/score/schedulerimpl.h
> @@ -452,19 +452,13 @@ RTEMS_INLINE_ROUTINE void _Scheduler_Release_job(
> * scheduler which support standard RTEMS features, this includes
> * time-slicing management.
> */
> -RTEMS_INLINE_ROUTINE void _Scheduler_Tick( void )
> +RTEMS_INLINE_ROUTINE void _Scheduler_Tick( const Per_CPU_Control *cpu )
> {
> - uint32_t cpu_count = _SMP_Get_processor_count();
> - uint32_t cpu_index;
> + const Scheduler_Control *scheduler = _Scheduler_Get_by_CPU( cpu );
> + Thread_Control *executing = cpu->executing;
>
> - for ( cpu_index = 0 ; cpu_index < cpu_count ; ++cpu_index ) {
> - const Per_CPU_Control *cpu = _Per_CPU_Get_by_index( cpu_index );
> - const Scheduler_Control *scheduler = _Scheduler_Get_by_CPU( cpu );
> - Thread_Control *executing = cpu->executing;
> -
> - if ( scheduler != NULL && executing != NULL ) {
> - ( *scheduler->Operations.tick )( scheduler, executing );
> - }
> + if ( scheduler != NULL && executing != NULL ) {
> + ( *scheduler->Operations.tick )( scheduler, executing );
> }
> }
>
> diff --git a/cpukit/score/include/rtems/score/thread.h
> b/cpukit/score/include/rtems/score/thread.h
> index 73776b3..44b706d 100644
> --- a/cpukit/score/include/rtems/score/thread.h
> +++ b/cpukit/score/include/rtems/score/thread.h
> @@ -347,6 +347,15 @@ typedef struct {
> } Thread_Wait_information;
>
> /**
> + * @brief Information required to manage a thread timer.
> + */
> +typedef struct {
> + ISR_LOCK_MEMBER( Lock )
> + Watchdog_Header *header;
> + Watchdog_Control Watchdog;
> +} Thread_Timer_information;
> +
> +/**
> * The following defines the control block used to manage
> * each thread proxy.
> *
> @@ -400,7 +409,7 @@ typedef struct {
> /** This field is the blocking information for this proxy. */
> Thread_Wait_information Wait;
> /** This field is the Watchdog used to manage proxy delays and
> timeouts. */
> - Watchdog_Control Timer;
> + Thread_Timer_information Timer;
> #if defined(RTEMS_MULTIPROCESSING)
> /** This field is the received response packet in an MP system. */
> MP_packet_Prefix *receive_packet;
> @@ -728,7 +737,7 @@ struct _Thread_Control {
> /** This field is the blocking information for this thread. */
> Thread_Wait_information Wait;
> /** This field is the Watchdog used to manage thread delays and
> timeouts. */
> - Watchdog_Control Timer;
> + Thread_Timer_information Timer;
> #if defined(RTEMS_MULTIPROCESSING)
> /** This field is the received response packet in an MP system. */
> MP_packet_Prefix *receive_packet;
> diff --git a/cpukit/score/include/rtems/score/threadimpl.h
> b/cpukit/score/include/rtems/score/threadimpl.h
> index 1377543..ec9851d 100644
> --- a/cpukit/score/include/rtems/score/threadimpl.h
> +++ b/cpukit/score/include/rtems/score/threadimpl.h
> @@ -33,6 +33,7 @@
> #include <rtems/score/threadqimpl.h>
> #include <rtems/score/todimpl.h>
> #include <rtems/score/freechain.h>
> +#include <rtems/score/watchdogimpl.h>
> #include <rtems/config.h>
>
> #ifdef __cplusplus
> @@ -1472,10 +1473,64 @@ RTEMS_INLINE_ROUTINE void
> _Thread_Wait_set_timeout_code(
> /**
> * @brief General purpose thread wait timeout.
> *
> - * @param[in] id Unused.
> - * @param[in] arg The thread.
> + * @param[in] watchdog The thread timer watchdog.
> */
> -void _Thread_Timeout( Objects_Id id, void *arg );
> +void _Thread_Timeout( Watchdog_Control *watchdog );
> +
> +RTEMS_INLINE_ROUTINE void _Thread_Timer_insert_relative(
> + Thread_Control *the_thread,
> + Per_CPU_Control *cpu,
> + Watchdog_Service_routine_entry routine,
> + Watchdog_Interval ticks
> +)
> +{
> + ISR_lock_Context lock_context;
> +
> + _ISR_lock_ISR_disable_and_acquire( &the_thread->Timer.Lock,
> &lock_context );
> +
> + the_thread->Timer.header = &cpu->Watchdog.Header[
> PER_CPU_WATCHDOG_RELATIVE ];
> + the_thread->Timer.Watchdog.routine = routine;
> + _Watchdog_Per_CPU_insert_relative( &the_thread->Timer.Watchdog, cpu,
> ticks );
> +
> + _ISR_lock_Release_and_ISR_enable( &the_thread->Timer.Lock,
> &lock_context );
> +}
> +
> +RTEMS_INLINE_ROUTINE void _Thread_Timer_insert_absolute(
> + Thread_Control *the_thread,
> + Per_CPU_Control *cpu,
> + Watchdog_Service_routine_entry routine,
> + uint64_t expire
> +)
> +{
> + ISR_lock_Context lock_context;
> +
> + _ISR_lock_ISR_disable_and_acquire( &the_thread->Timer.Lock,
> &lock_context );
> +
> + the_thread->Timer.header = &cpu->Watchdog.Header[
> PER_CPU_WATCHDOG_ABSOLUTE ];
> + the_thread->Timer.Watchdog.routine = routine;
> + _Watchdog_Per_CPU_insert_absolute( &the_thread->Timer.Watchdog, cpu,
> expire );
> +
> + _ISR_lock_Release_and_ISR_enable( &the_thread->Timer.Lock,
> &lock_context );
> +}
> +
> +RTEMS_INLINE_ROUTINE void _Thread_Timer_remove( Thread_Control
> *the_thread )
> +{
> + ISR_lock_Context lock_context;
> +
> + _ISR_lock_ISR_disable_and_acquire( &the_thread->Timer.Lock,
> &lock_context );
> +
> + _Watchdog_Per_CPU_remove(
> + &the_thread->Timer.Watchdog,
> +#if defined(RTEMS_SMP)
> + the_thread->Timer.Watchdog.cpu,
> +#else
> + _Per_CPU_Get(),
> +#endif
> + the_thread->Timer.header
> + );
> +
> + _ISR_lock_Release_and_ISR_enable( &the_thread->Timer.Lock,
> &lock_context );
> +}
>
> RTEMS_INLINE_ROUTINE void _Thread_Debug_set_real_processor(
> Thread_Control *the_thread,
> diff --git a/cpukit/score/include/rtems/score/todimpl.h
> b/cpukit/score/include/rtems/score/todimpl.h
> index b61651c..b1f8a6d 100644
> --- a/cpukit/score/include/rtems/score/todimpl.h
> +++ b/cpukit/score/include/rtems/score/todimpl.h
> @@ -132,15 +132,6 @@ extern "C" {
> */
> typedef struct {
> /**
> - * @brief Time of day seconds trigger.
> - *
> - * This value specifies the nanoseconds since the last time of day
> second.
> - * It is updated and evaluated in _TOD_Tickle_ticks(). It is set in
> - * _TOD_Set_with_timestamp().
> - */
> - uint32_t seconds_trigger;
> -
> - /**
> * @brief Indicates if the time of day is set.
> *
> * This is true if the application has set the current
> @@ -273,14 +264,6 @@ static inline uint32_t _TOD_Seconds_since_epoch( void
> )
> }
>
> /**
> - * @brief Increments time of day at each clock tick.
> - *
> - * This routine increments the ticks field of the current time of
> - * day at each clock tick.
> - */
> -void _TOD_Tickle_ticks( void );
> -
> -/**
> * @brief Gets number of ticks in a second.
> *
> * This method returns the number of ticks in a second.
> diff --git a/cpukit/score/include/rtems/score/watchdog.h
> b/cpukit/score/include/rtems/score/watchdog.h
> index bad7269..b371f94 100644
> --- a/cpukit/score/include/rtems/score/watchdog.h
> +++ b/cpukit/score/include/rtems/score/watchdog.h
> @@ -20,7 +20,11 @@
> #ifndef _RTEMS_SCORE_WATCHDOG_H
> #define _RTEMS_SCORE_WATCHDOG_H
>
> -#include <rtems/score/object.h>
> +#include <rtems/score/basedefs.h>
> +#include <rtems/score/chain.h>
> +#include <rtems/score/rbtree.h>
> +
> +struct Per_CPU_Control;
>
> #ifdef __cplusplus
> extern "C" {
> @@ -39,6 +43,8 @@ extern "C" {
> */
> /**@{*/
>
> +typedef struct Watchdog_Control Watchdog_Control;
> +
> /**
> * @brief Type is used to specify the length of intervals.
> *
> @@ -58,10 +64,8 @@ typedef void Watchdog_Service_routine;
> *
> * This type define a pointer to a watchdog service routine.
> */
> -typedef Watchdog_Service_routine ( *Watchdog_Service_routine_entry )(
> - Objects_Id,
> - void *
> - );
> +typedef Watchdog_Service_routine
> + ( *Watchdog_Service_routine_entry )( Watchdog_Control * );
>
> /**
> * @brief The constant for indefinite wait.
> @@ -72,22 +76,20 @@ typedef Watchdog_Service_routine (
> *Watchdog_Service_routine_entry )(
> #define WATCHDOG_NO_TIMEOUT 0
>
> /**
> - * @brief Set of the states which a watchdog timer may be at any given
> time.
> - *
> - * This enumerated type is the set of the states in which a
> - * watchdog timer may be at any given time.
> + * @brief The watchdog header to manage scheduled watchdogs.
> */
> +typedef struct {
> + /**
> + * @brief Red-black tree of scheduled watchdogs sorted by expiration
> time.
> + */
> + RBTree_Control Watchdogs;
>
> -typedef enum {
> - /** This is the state when the watchdog is off all chains */
> - WATCHDOG_INACTIVE,
> - /** This is the state when the watchdog is off all chains, but we are
> - * currently searching for the insertion point.
> + /**
> + * @brief The scheduled watchdog with the earliest expiration time or
> NULL in
> + * case no watchdog is scheduled.
> */
> - WATCHDOG_BEING_INSERTED,
> - /** This is the state when the watchdog is on a chain, and allowed to
> fire. */
> - WATCHDOG_ACTIVE
> -} Watchdog_States;
> + RBTree_Node *first;
> +} Watchdog_Header;
>
> /**
> * @brief The control block used to manage each watchdog timer.
> @@ -95,30 +97,35 @@ typedef enum {
> * The following record defines the control block used
> * to manage each watchdog timer.
> */
> -typedef struct {
> - /** This field is a Chain Node structure and allows this to be placed on
> - * chains for set management.
> - */
> - Chain_Node Node;
> - /** This field is the state of the watchdog. */
> - Watchdog_States state;
> - /** This field is the initially requested interval. */
> - Watchdog_Interval initial;
> - /** This field is the remaining portion of the interval. */
> - Watchdog_Interval delta_interval;
> - /** This field is the number of system clock ticks when this was
> scheduled. */
> - Watchdog_Interval start_time;
> - /** This field is the number of system clock ticks when this was
> suspended. */
> - Watchdog_Interval stop_time;
> - /** This field is the function to invoke. */
> - Watchdog_Service_routine_entry routine;
> - /** This field is the Id to pass as an argument to the routine. */
> - Objects_Id id;
> - /** This field is an untyped pointer to user data that is passed to the
> - * watchdog handler routine.
> +struct Watchdog_Control {
> + /**
> + * @brief Nodes for the watchdog.
> */
> - void *user_data;
> -} Watchdog_Control;
> + union {
> + /**
> + * @brief This field is a Red-Black Tree Node structure and allows
> this to
> + * be placed on Red-Black Trees for set management.
> + */
> + RBTree_Node RBTree;
> +
> + /**
> + * @brief This field is a Chain Node structure and allows this to
> + * be placed on Red-Black Trees for set management.
> + */
> + Chain_Node Chain;
> + } Node;
> +
> +#if defined(RTEMS_SMP)
> + /** @brief This field references the processor of this watchdog
> control. */
> + struct Per_CPU_Control *cpu;
> +#endif
> +
> + /** @brief This field is the function to invoke. */
> + Watchdog_Service_routine_entry routine;
> +
> + /** @brief This field is the expiration time point. */
> + uint64_t expire;
> +};
>
> /**
> * @brief The watchdog ticks counter.
> diff --git a/cpukit/score/include/rtems/score/watchdogimpl.h
> b/cpukit/score/include/rtems/score/watchdogimpl.h
> index 49ac2a1..0f6947f 100644
> --- a/cpukit/score/include/rtems/score/watchdogimpl.h
> +++ b/cpukit/score/include/rtems/score/watchdogimpl.h
> @@ -21,9 +21,11 @@
>
> #include <rtems/score/watchdog.h>
> #include <rtems/score/assert.h>
> -#include <rtems/score/chainimpl.h>
> #include <rtems/score/isrlock.h>
> #include <rtems/score/percpu.h>
> +#include <rtems/score/rbtreeimpl.h>
> +
> +#include <sys/timespec.h>
>
> #ifdef __cplusplus
> extern "C" {
> @@ -35,241 +37,116 @@ extern "C" {
> */
>
> /**
> - * @brief Watchdog initializer for static initialization.
> - *
> - * @see _Watchdog_Initialize().
> - */
> -#define WATCHDOG_INITIALIZER( routine, id, user_data ) \
> - { \
> - { NULL, NULL }, \
> - WATCHDOG_INACTIVE, \
> - 0, 0, 0, 0, \
> - ( routine ), ( id ), ( user_data ) \
> - }
> -
> -/**
> - * @brief Iterator item to synchronize concurrent insert, remove and
> tickle
> - * operations.
> + * @brief Watchdog states.
> */
> -typedef struct {
> +typedef enum {
> /**
> - * @brief A node for a Watchdog_Header::Iterators chain.
> + * @brief The watchdog is scheduled and a black node in the red-black
> tree.
> */
> - Chain_Node Node;
> + WATCHDOG_SCHEDULED_BLACK,
>
> /**
> - * @brief The current delta interval of the new watchdog to insert.
> + * @brief The watchdog is scheduled and a black node in the red-black
> tree.
> */
> - Watchdog_Interval delta_interval;
> + WATCHDOG_SCHEDULED_RED,
>
> /**
> - * @brief The current watchdog of the chain on the way to insert the new
> - * watchdog.
> + * @brief The watchdog is inactive.
> */
> - Chain_Node *current;
> -} Watchdog_Iterator;
> -
> -/**
> - * @brief Watchdog header.
> - */
> -typedef struct {
> - /**
> - * @brief ISR lock to protect this watchdog chain.
> - */
> - ISR_LOCK_MEMBER( Lock )
> + WATCHDOG_INACTIVE,
>
> /**
> - * @brief The chain of active or transient watchdogs.
> - */
> - Chain_Control Watchdogs;
> -
> - /**
> - * @brief Currently active iterators.
> + * @brief The watchdog is on a chain of pending watchdogs.
> *
> - * The iterators are registered in _Watchdog_Insert() and updated in
> case the
> - * watchdog chain changes.
> + * This state is used by the timer server for example.
> */
> - Chain_Control Iterators;
> -} Watchdog_Header;
> + WATCHDOG_PENDING
> +} Watchdog_State;
>
> /**
> - * @brief Watchdog chain which is managed at ticks.
> + * @brief Watchdog initializer for static initialization.
> *
> - * This is the watchdog chain which is managed at ticks.
> - */
> -extern Watchdog_Header _Watchdog_Ticks_header;
> -
> -/**
> - * @brief Watchdog chain which is managed at second boundaries.
> + * The processor of this watchdog is set to processor with index zero.
> *
> - * This is the watchdog chain which is managed at second boundaries.
> + * @see _Watchdog_Preinitialize().
> */
> -extern Watchdog_Header _Watchdog_Seconds_header;
> -
> -RTEMS_INLINE_ROUTINE void _Watchdog_Acquire(
> - Watchdog_Header *header,
> - ISR_lock_Context *lock_context
> -)
> -{
> - _ISR_lock_ISR_disable_and_acquire( &header->Lock, lock_context );
> -}
> +#if defined(RTEMS_SMP)
> + #define WATCHDOG_INITIALIZER( routine ) \
> + { \
> + { { { NULL, NULL, NULL, WATCHDOG_INACTIVE } } }, \
> + &_Per_CPU_Information[ 0 ].per_cpu, \
> + ( routine ), \
> + 0 \
> + }
> +#else
> + #define WATCHDOG_INITIALIZER( routine ) \
> + { \
> + { { { NULL, NULL, NULL, WATCHDOG_INACTIVE } } }, \
> + ( routine ), \
> + 0 \
> + }
> +#endif
>
> -RTEMS_INLINE_ROUTINE void _Watchdog_Release(
> - Watchdog_Header *header,
> - ISR_lock_Context *lock_context
> +RTEMS_INLINE_ROUTINE void _Watchdog_Header_initialize(
> + Watchdog_Header *header
> )
> {
> - _ISR_lock_Release_and_ISR_enable( &header->Lock, lock_context );
> + _RBTree_Initialize_empty( &header->Watchdogs );
> + header->first = NULL;
> }
>
> -RTEMS_INLINE_ROUTINE void _Watchdog_Flash(
> - Watchdog_Header *header,
> - ISR_lock_Context *lock_context
> +RTEMS_INLINE_ROUTINE void _Watchdog_Header_destroy(
> + Watchdog_Header *header
> )
> {
> - _ISR_lock_Flash( &header->Lock, lock_context );
> + /* Do nothing */
> + (void) header;
> }
>
> /**
> - * @brief Initialize the watchdog handler.
> - *
> - * This routine initializes the watchdog handler. The watchdog
> - * synchronization flag is initialized and the watchdog chains are
> - * initialized and emptied.
> - */
> -void _Watchdog_Handler_initialization( void );
> -
> -/**
> * @brief Performs a watchdog tick.
> *
> * @param cpu The processor for this watchdog tick.
> */
> -void _Watchdog_Tick( Per_CPU_Control *cpu );
> -
> -/**
> - * @brief Removes @a the_watchdog from the watchdog chain.
> - *
> - * This routine removes @a the_watchdog from the watchdog chain on which
> - * it resides and returns the state @a the_watchdog timer was in.
> - *
> - * @param[in] header The watchdog chain.
> - * @param[in] the_watchdog will be removed
> - * @retval the state in which @a the_watchdog was in when removed
> - */
> -Watchdog_States _Watchdog_Remove (
> - Watchdog_Header *header,
> - Watchdog_Control *the_watchdog
> -);
> -
> -/**
> - * @brief Adjusts the header watchdog chain in the backward direction for
> - * units ticks.
> - *
> - * @param[in] header The watchdog chain.
> - * @param[in] units The units of ticks to adjust.
> - */
> -void _Watchdog_Adjust_backward(
> - Watchdog_Header *header,
> - Watchdog_Interval units
> -);
> -
> -/**
> - * @brief Adjusts the watchdogs in backward direction in a locked context.
> - *
> - * The caller must be the owner of the watchdog lock and will be the owner
> - * after the call.
> - *
> - * @param[in] header The watchdog header.
> - * @param[in] units The units of ticks to adjust.
> - *
> - * @see _Watchdog_Adjust_forward().
> - */
> -void _Watchdog_Adjust_backward_locked(
> - Watchdog_Header *header,
> - Watchdog_Interval units
> -);
> +void _Watchdog_Tick( struct Per_CPU_Control *cpu );
>
> -/**
> - * @brief Adjusts the header watchdog chain in the forward direction for
> units
> - * ticks.
> - *
> - * This may lead to several _Watchdog_Tickle() invocations.
> - *
> - * @param[in] header The watchdog chain.
> - * @param[in] units The units of ticks to adjust.
> - */
> -void _Watchdog_Adjust_forward(
> - Watchdog_Header *header,
> - Watchdog_Interval units
> -);
> +RTEMS_INLINE_ROUTINE Watchdog_State _Watchdog_Get_state(
> + const Watchdog_Control *the_watchdog
> +)
> +{
> + return RB_COLOR( &the_watchdog->Node.RBTree, Node );
> +}
>
> -/**
> - * @brief Adjusts the watchdogs in forward direction in a locked context.
> - *
> - * The caller must be the owner of the watchdog lock and will be the owner
> - * after the call. This function may release and acquire the watchdog
> lock
> - * internally.
> - *
> - * @param[in] header The watchdog header.
> - * @param[in] units The units of ticks to adjust.
> - * @param[in] lock_context The lock context.
> - *
> - * @see _Watchdog_Adjust_forward().
> - */
> -void _Watchdog_Adjust_forward_locked(
> - Watchdog_Header *header,
> - Watchdog_Interval units,
> - ISR_lock_Context *lock_context
> -);
> +RTEMS_INLINE_ROUTINE void _Watchdog_Set_state(
> + Watchdog_Control *the_watchdog,
> + Watchdog_State state
> +)
> +{
> + RB_COLOR( &the_watchdog->Node.RBTree, Node ) = state;
> +}
>
> -/**
> - * @brief Inserts @a the_watchdog into the @a header watchdog chain
> - * for a time of @a units.
> - *
> - * This routine inserts @a the_watchdog into the @a header watchdog chain
> - * for a time of @a units.
> - * Update the delta interval counters.
> - *
> - * @param[in] header is @a the_watchdog list to insert @a the_watchdog on
> - * @param[in] the_watchdog is the watchdog to insert
> - */
> -void _Watchdog_Insert (
> - Watchdog_Header *header,
> - Watchdog_Control *the_watchdog
> -);
> +RTEMS_INLINE_ROUTINE Per_CPU_Control *_Watchdog_Get_CPU(
> + const Watchdog_Control *the_watchdog
> +)
> +{
> +#if defined(RTEMS_SMP)
> + return the_watchdog->cpu;
> +#else
> + return _Per_CPU_Get_by_index( 0 );
> +#endif
> +}
>
> -/**
> - * @brief Inserts the watchdog in a locked context.
> - *
> - * The caller must be the owner of the watchdog lock and will be the owner
> - * after the call. This function may release and acquire the watchdog
> lock
> - * internally.
> - *
> - * @param[in] header The watchdog header.
> - * @param[in] the_watchdog The watchdog.
> - * @param[in] lock_context The lock context.
> - *
> - * @see _Watchdog_Insert().
> - */
> -void _Watchdog_Insert_locked(
> - Watchdog_Header *header,
> +RTEMS_INLINE_ROUTINE void _Watchdog_Set_CPU(
> Watchdog_Control *the_watchdog,
> - ISR_lock_Context *lock_context
> -);
> -
> -/**
> - * @brief This routine is invoked at appropriate intervals to update
> - * the @a header watchdog chain.
> - *
> - * This routine is invoked at appropriate intervals to update
> - * the @a header watchdog chain.
> - * This routine decrements the delta counter in response to a tick.
> - *
> - * @param[in] header is the watchdog chain to tickle
> - */
> -void _Watchdog_Tickle (
> - Watchdog_Header *header
> -);
> + Per_CPU_Control *cpu
> +)
> +{
> +#if defined(RTEMS_SMP)
> + the_watchdog->cpu = cpu;
> +#else
> + (void) cpu;
> +#endif
> +}
>
> /**
> * @brief Pre-initializes a watchdog.
> @@ -280,228 +157,261 @@ void _Watchdog_Tickle (
> * @param[in] the_watchdog The uninitialized watchdog.
> */
> RTEMS_INLINE_ROUTINE void _Watchdog_Preinitialize(
> - Watchdog_Control *the_watchdog
> + Watchdog_Control *the_watchdog,
> + Per_CPU_Control *cpu
> )
> {
> - the_watchdog->state = WATCHDOG_INACTIVE;
> + _Watchdog_Set_CPU( the_watchdog, cpu );
> + _Watchdog_Set_state( the_watchdog, WATCHDOG_INACTIVE );
> +
> #if defined(RTEMS_DEBUG)
> the_watchdog->routine = NULL;
> - the_watchdog->id = 0;
> - the_watchdog->user_data = NULL;
> + the_watchdog->expire = 0;
> #endif
> }
>
> /**
> - * This routine initializes the specified watchdog. The watchdog is
> - * made inactive, the watchdog id and handler routine are set to the
> - * specified values.
> + * @brief Initializes a watchdog with a new service routine.
> + *
> + * The watchdog must be inactive.
> */
> -
> RTEMS_INLINE_ROUTINE void _Watchdog_Initialize(
> Watchdog_Control *the_watchdog,
> - Watchdog_Service_routine_entry routine,
> - Objects_Id id,
> - void *user_data
> + Watchdog_Service_routine_entry routine
> )
> {
> - _Assert( the_watchdog->state == WATCHDOG_INACTIVE );
> - the_watchdog->routine = routine;
> - the_watchdog->id = id;
> - the_watchdog->user_data = user_data;
> + _Assert( _Watchdog_Get_state( the_watchdog ) == WATCHDOG_INACTIVE );
> + the_watchdog->routine = routine;
> }
>
> -/**
> - * This routine returns true if the watchdog timer is in the ACTIVE
> - * state, and false otherwise.
> - */
> -
> -RTEMS_INLINE_ROUTINE bool _Watchdog_Is_active(
> - Watchdog_Control *the_watchdog
> -)
> -{
> -
> - return ( the_watchdog->state == WATCHDOG_ACTIVE );
> +void _Watchdog_Do_tickle(
> + Watchdog_Header *header,
> + uint64_t now,
> +#if defined(RTEMS_SMP)
> + ISR_lock_Control *lock,
> +#endif
> + ISR_lock_Context *lock_context
> +);
>
> -}
> +#if defined(RTEMS_SMP)
> + #define _Watchdog_Tickle( header, now, lock, lock_context ) \
> + _Watchdog_Do_tickle( header, now, lock, lock_context )
> +#else
> + #define _Watchdog_Tickle( header, now, lock, lock_context ) \
> + _Watchdog_Do_tickle( header, now, lock_context )
> +#endif
>
> /**
> - * This routine activates THE_WATCHDOG timer which is already
> - * on a watchdog chain.
> + * @brief Inserts a watchdog into the set of scheduled watchdogs
> according to
> + * the specified expiration time.
> + *
> + * The watchdog must be inactive.
> */
> +void _Watchdog_Insert(
> + Watchdog_Header *header,
> + Watchdog_Control *the_watchdog,
> + uint64_t expire
> +);
>
> -RTEMS_INLINE_ROUTINE void _Watchdog_Activate(
> +/**
> + * @brief In case the watchdog is scheduled, then it is removed from the
> set of
> + * scheduled watchdogs.
> + *
> + * The watchdog must be initialized before this call.
> + */
> +void _Watchdog_Remove(
> + Watchdog_Header *header,
> Watchdog_Control *the_watchdog
> -)
> -{
> -
> - the_watchdog->state = WATCHDOG_ACTIVE;
> -
> -}
> +);
>
> /**
> - * This routine is invoked at each clock tick to update the ticks
> - * watchdog chain.
> + * @brief In case the watchdog is scheduled, then it is removed from the
> set of
> + * scheduled watchdogs.
> + *
> + * The watchdog must be initialized before this call.
> + *
> + * @retval 0 The now time is greater than or equal to the expiration time
> of
> + * the watchdog.
> + * @retval other The difference of the now and expiration time.
> */
> -
> -RTEMS_INLINE_ROUTINE void _Watchdog_Tickle_ticks( void )
> +RTEMS_INLINE_ROUTINE uint64_t _Watchdog_Cancel(
> + Watchdog_Header *header,
> + Watchdog_Control *the_watchdog,
> + uint64_t now
> +)
> {
> + uint64_t expire;
> + uint64_t remaining;
>
> - _Watchdog_Tickle( &_Watchdog_Ticks_header );
> -
> -}
> -
> -/**
> - * This routine is invoked at each clock tick to update the seconds
> - * watchdog chain.
> - */
> + expire = the_watchdog->expire;
>
> -RTEMS_INLINE_ROUTINE void _Watchdog_Tickle_seconds( void )
> -{
> + if ( now < expire ) {
> + remaining = expire - now;
> + } else {
> + remaining = 0;
> + }
>
> - _Watchdog_Tickle( &_Watchdog_Seconds_header );
> + _Watchdog_Remove( header, the_watchdog );
>
> + return remaining;
> }
>
> -/**
> - * This routine inserts THE_WATCHDOG into the ticks watchdog chain
> - * for a time of UNITS ticks. The INSERT_MODE indicates whether
> - * THE_WATCHDOG is to be activated automatically or later, explicitly
> - * by the caller.
> - */
> -
> -RTEMS_INLINE_ROUTINE void _Watchdog_Insert_ticks(
> - Watchdog_Control *the_watchdog,
> - Watchdog_Interval units
> +RTEMS_INLINE_ROUTINE bool _Watchdog_Is_scheduled(
> + const Watchdog_Control *the_watchdog
> )
> {
> -
> - the_watchdog->initial = units;
> -
> - _Watchdog_Insert( &_Watchdog_Ticks_header, the_watchdog );
> -
> + return _Watchdog_Get_state( the_watchdog ) < WATCHDOG_INACTIVE;
> }
>
> -/**
> - * This routine inserts THE_WATCHDOG into the seconds watchdog chain
> - * for a time of UNITS seconds. The INSERT_MODE indicates whether
> - * THE_WATCHDOG is to be activated automatically or later, explicitly
> - * by the caller.
> - */
> -
> -RTEMS_INLINE_ROUTINE void _Watchdog_Insert_seconds(
> - Watchdog_Control *the_watchdog,
> - Watchdog_Interval units
> +RTEMS_INLINE_ROUTINE void _Watchdog_Next_first(
> + Watchdog_Header *header,
> + Watchdog_Control *the_watchdog
> )
> {
> + RBTree_Node *node = _RBTree_Right( &the_watchdog->Node.RBTree );
>
> - the_watchdog->initial = units;
> + if ( node != NULL ) {
> + RBTree_Node *left;
>
> - _Watchdog_Insert( &_Watchdog_Seconds_header, the_watchdog );
> + while ( ( left = _RBTree_Left( node ) ) != NULL ) {
> + node = left;
> + }
>
> + header->first = node;
> + } else {
> + header->first = _RBTree_Parent( &the_watchdog->Node.RBTree );
> + }
> }
>
> -RTEMS_INLINE_ROUTINE Watchdog_States _Watchdog_Remove_ticks(
> - Watchdog_Control *the_watchdog
> +RTEMS_INLINE_ROUTINE uint64_t _Watchdog_Ticks_from_seconds(
> + uint32_t seconds
> )
> {
> - return _Watchdog_Remove( &_Watchdog_Ticks_header, the_watchdog );
> -}
> + uint64_t ticks = seconds;
>
> -RTEMS_INLINE_ROUTINE Watchdog_States _Watchdog_Remove_seconds(
> - Watchdog_Control *the_watchdog
> -)
> -{
> - return _Watchdog_Remove( &_Watchdog_Seconds_header, the_watchdog );
> -}
> + ticks <<= 30;
>
> -/**
> - * This routine resets THE_WATCHDOG timer to its state at INSERT
> - * time. This routine is valid only on interval watchdog timers
> - * and is used to make an interval watchdog timer fire "every" so
> - * many ticks.
> - */
> + return ticks;
> +}
>
> -RTEMS_INLINE_ROUTINE void _Watchdog_Reset_ticks(
> - Watchdog_Control *the_watchdog
> +RTEMS_INLINE_ROUTINE uint64_t _Watchdog_Ticks_from_timespec(
> + const struct timespec *ts
> )
> {
> + uint64_t ticks = (uint64_t) ts->tv_sec;
>
> - _Watchdog_Remove_ticks( the_watchdog );
> + _Assert( ticks < 0x400000000 );
> + _Assert( ts->tv_nsec >= 0 );
> + _Assert( ts->tv_nsec < 1000000000 );
>
> - _Watchdog_Insert( &_Watchdog_Ticks_header, the_watchdog );
> + ticks <<= 30;
> + ticks |= ts->tv_nsec;
>
> + return ticks;
> }
>
> -/**
> - * This routine returns a pointer to the watchdog timer following
> - * THE_WATCHDOG on the watchdog chain.
> - */
> +#define _Watchdog_Per_CPU_acquire( cpu, lock_context ) \
> + _ISR_lock_Acquire( &( cpu )->Watchdog.Lock, lock_context )
>
> -RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_Next(
> - Watchdog_Control *the_watchdog
> +#define _Watchdog_Per_CPU_release( cpu, lock_context ) \
> + _ISR_lock_Release( &( cpu )->Watchdog.Lock, lock_context )
> +
> +RTEMS_INLINE_ROUTINE void _Watchdog_Per_CPU_insert_relative(
> + Watchdog_Control *the_watchdog,
> + Per_CPU_Control *cpu,
> + uint32_t ticks
> )
> {
> + ISR_lock_Context lock_context;
>
> - return ( (Watchdog_Control *) the_watchdog->Node.next );
> + _Watchdog_Set_CPU( the_watchdog, cpu );
>
> + _Watchdog_Per_CPU_acquire( cpu, &lock_context );
> + _Watchdog_Insert(
> + &cpu->Watchdog.Header[ PER_CPU_WATCHDOG_RELATIVE ],
> + the_watchdog,
> + cpu->Watchdog.ticks + ticks
> + );
> + _Watchdog_Per_CPU_release( cpu, &lock_context );
> }
>
> -/**
> - * This routine returns a pointer to the watchdog timer preceding
> - * THE_WATCHDOG on the watchdog chain.
> - */
> -
> -RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_Previous(
> - Watchdog_Control *the_watchdog
> +RTEMS_INLINE_ROUTINE void _Watchdog_Per_CPU_insert_absolute(
> + Watchdog_Control *the_watchdog,
> + Per_CPU_Control *cpu,
> + uint64_t expire
> )
> {
> + ISR_lock_Context lock_context;
>
> - return ( (Watchdog_Control *) the_watchdog->Node.previous );
> + _Watchdog_Set_CPU( the_watchdog, cpu );
>
> + _Watchdog_Per_CPU_acquire( cpu, &lock_context );
> + _Watchdog_Insert(
> + &cpu->Watchdog.Header[ PER_CPU_WATCHDOG_ABSOLUTE ],
> + the_watchdog,
> + expire
> + );
> + _Watchdog_Per_CPU_release( cpu, &lock_context );
> }
>
> -/**
> - * This routine returns a pointer to the first watchdog timer
> - * on the watchdog chain HEADER.
> - */
> -
> -RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_First(
> - Watchdog_Header *header
> +RTEMS_INLINE_ROUTINE void _Watchdog_Per_CPU_remove(
> + Watchdog_Control *the_watchdog,
> + Per_CPU_Control *cpu,
> + Watchdog_Header *header
> )
> {
> -
> - return ( (Watchdog_Control *) _Chain_First( &header->Watchdogs ) );
> -
> + ISR_lock_Context lock_context;
> +
> + _Watchdog_Per_CPU_acquire( cpu, &lock_context );
> + _Watchdog_Remove(
> + header,
> + the_watchdog
> + );
> + _Watchdog_Per_CPU_release( cpu, &lock_context );
> }
>
> -/**
> - * This routine returns a pointer to the last watchdog timer
> - * on the watchdog chain HEADER.
> - */
> -
> -RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_Last(
> - Watchdog_Header *header
> +RTEMS_INLINE_ROUTINE void _Watchdog_Per_CPU_remove_relative(
> + Watchdog_Control *the_watchdog
> )
> {
> -
> - return ( (Watchdog_Control *) _Chain_Last( &header->Watchdogs ) );
> -
> + Per_CPU_Control *cpu;
> +
> + cpu = _Watchdog_Get_CPU( the_watchdog );
> + _Watchdog_Per_CPU_remove(
> + the_watchdog,
> + cpu,
> + &cpu->Watchdog.Header[ PER_CPU_WATCHDOG_RELATIVE ]
> + );
> }
>
> -RTEMS_INLINE_ROUTINE bool _Watchdog_Is_empty(
> - const Watchdog_Header *header
> +RTEMS_INLINE_ROUTINE void _Watchdog_Per_CPU_remove_absolute(
> + Watchdog_Control *the_watchdog
> )
> {
> - return _Chain_Is_empty( &header->Watchdogs );
> + Per_CPU_Control *cpu;
> +
> + cpu = _Watchdog_Get_CPU( the_watchdog );
> + _Watchdog_Per_CPU_remove(
> + the_watchdog,
> + cpu,
> + &cpu->Watchdog.Header[ PER_CPU_WATCHDOG_ABSOLUTE ]
> + );
> }
>
> -RTEMS_INLINE_ROUTINE void _Watchdog_Header_initialize(
> - Watchdog_Header *header
> +RTEMS_INLINE_ROUTINE void _Watchdog_Per_CPU_tickle_absolute(
> + Per_CPU_Control *cpu,
> + uint64_t now
> )
> {
> - _ISR_lock_Initialize( &header->Lock, "Watchdog" );
> - _Chain_Initialize_empty( &header->Watchdogs );
> - _Chain_Initialize_empty( &header->Iterators );
> + ISR_lock_Context lock_context;
> +
> + _ISR_lock_ISR_disable_and_acquire( &cpu->Watchdog.Lock, &lock_context );
> + _Watchdog_Tickle(
> + &cpu->Watchdog.Header[ PER_CPU_WATCHDOG_ABSOLUTE ],
> + now,
> + &cpu->Watchdog.Lock,
> + &lock_context
> + );
> }
>
> /** @} */
> diff --git a/cpukit/score/src/condition.c b/cpukit/score/src/condition.c
> index 22c2a9b..4206819 100644
> --- a/cpukit/score/src/condition.c
> +++ b/cpukit/score/src/condition.c
> @@ -282,7 +282,7 @@ static int _Condition_Wake( struct _Condition_Control
> *_condition, int count )
>
> next = _Chain_Next( node );
> thread = THREAD_CHAIN_NODE_TO_THREAD( node );
> - _Watchdog_Remove_ticks( &thread->Timer );
> + _Thread_Timer_remove( thread );
> _Thread_Unblock( thread );
>
> node = next;
> diff --git a/cpukit/score/src/coretodset.c b/cpukit/score/src/coretodset.c
> index 3230179..b2efc07 100644
> --- a/cpukit/score/src/coretodset.c
> +++ b/cpukit/score/src/coretodset.c
> @@ -26,30 +26,26 @@ void _TOD_Set_with_timestamp(
> const Timestamp_Control *tod_as_timestamp
> )
> {
> - struct timespec ts;
> - uint32_t nanoseconds;
> - Watchdog_Interval seconds_next;
> - Watchdog_Interval seconds_now;
> - Watchdog_Header *header;
> + struct timespec tod_as_timespec;
> + uint64_t tod_as_ticks;
> + uint32_t cpu_count;
> + uint32_t cpu_index;
>
> - _Timestamp_To_timespec( tod_as_timestamp, &ts );
> - nanoseconds = ts.tv_nsec;
> - seconds_next = ts.tv_sec;
> + _Timestamp_To_timespec( tod_as_timestamp, &tod_as_timespec );
>
> _Thread_Disable_dispatch();
>
> - seconds_now = _TOD_Seconds_since_epoch();
> + _Timecounter_Set_clock( &tod_as_timespec );
>
> - _Timecounter_Set_clock( &ts );
> + tod_as_ticks = _Watchdog_Ticks_from_timespec( &tod_as_timespec );
> + cpu_count = _SMP_Get_processor_count();
>
> - header = &_Watchdog_Seconds_header;
> + for ( cpu_index = 0 ; cpu_index < cpu_count ; ++cpu_index ) {
> + Per_CPU_Control *cpu = _Per_CPU_Get_by_index( cpu_index );
>
> - if ( seconds_next < seconds_now )
> - _Watchdog_Adjust_backward( header, seconds_now - seconds_next );
> - else
> - _Watchdog_Adjust_forward( header, seconds_next - seconds_now );
> + _Watchdog_Per_CPU_tickle_absolute( cpu, tod_as_ticks );
> + }
>
> - _TOD.seconds_trigger = nanoseconds;
> _TOD.is_set = true;
>
> _Thread_Enable_dispatch();
> diff --git a/cpukit/score/src/coretodtickle.c
> b/cpukit/score/src/coretodtickle.c
> deleted file mode 100644
> index 3d7c71e..0000000
> --- a/cpukit/score/src/coretodtickle.c
> +++ /dev/null
> @@ -1,36 +0,0 @@
> -/**
> - * @file
> - *
> - * @brief Increments time of day at each clock tick
> - *
> - * @ingroup ScoreTOD
> - */
> -
> -/* COPYRIGHT (c) 1989-2014.
> - * On-Line Applications Research Corporation (OAR).
> - *
> - * The license and distribution terms for this file may be
> - * found in the file LICENSE in this distribution or at
> - * http://www.rtems.org/license/LICENSE.
> - */
> -
> -#if HAVE_CONFIG_H
> -#include "config.h"
> -#endif
> -
> -#include <rtems/score/todimpl.h>
> -#include <rtems/score/watchdogimpl.h>
> -#include <rtems/config.h>
> -
> -void _TOD_Tickle_ticks( void )
> -{
> - /* Update the counter of ticks since boot */
> - _Watchdog_Ticks_since_boot += 1;
> -
> - _TOD.seconds_trigger += rtems_configuration_get_nanoseconds_per_tick();
> - if ( _TOD.seconds_trigger >= 1000000000UL ) {
> - _TOD.seconds_trigger -= 1000000000UL;
> - _Watchdog_Tickle_seconds();
> - }
> -}
> -
> diff --git a/cpukit/score/src/kern_tc.c b/cpukit/score/src/kern_tc.c
> index e56c292..316a16f 100644
> --- a/cpukit/score/src/kern_tc.c
> +++ b/cpukit/score/src/kern_tc.c
> @@ -1971,6 +1971,7 @@ tc_ticktock(int cnt)
> return;
> count = 0;
> #else /* __rtems__ */
> +#include <rtems/score/smp.h>
> void
> _Timecounter_Tick(void)
> {
> @@ -2021,7 +2022,7 @@ _Timecounter_Tick_simple(uint32_t delta, uint32_t
> offset,
>
> _Timecounter_Release(lock_context);
>
> - _Watchdog_Tick(_Per_CPU_Get());
> + _Watchdog_Tick(_Per_CPU_Get_snapshot());
> }
> #endif /* __rtems__ */
>
> diff --git a/cpukit/score/src/smp.c b/cpukit/score/src/smp.c
> index 9d9507d..85256b0 100644
> --- a/cpukit/score/src/smp.c
> +++ b/cpukit/score/src/smp.c
> @@ -87,6 +87,7 @@ void _SMP_Handler_initialize( void )
> for ( cpu_index = 0 ; cpu_index < cpu_max; ++cpu_index ) {
> Per_CPU_Control *cpu = _Per_CPU_Get_by_index( cpu_index );
>
> + _ISR_lock_Initialize( &cpu->Watchdog.Lock, "Watchdog" );
> _SMP_ticket_lock_Initialize( &cpu->Lock );
> _SMP_lock_Stats_initialize( &cpu->Lock_stats, "Per-CPU" );
> }
> diff --git a/cpukit/score/src/threadinitialize.c
> b/cpukit/score/src/threadinitialize.c
> index a49406f..0b5fd3a 100644
> --- a/cpukit/score/src/threadinitialize.c
> +++ b/cpukit/score/src/threadinitialize.c
> @@ -160,6 +160,10 @@ bool _Thread_Initialize(
> the_thread->Start.budget_algorithm = budget_algorithm;
> the_thread->Start.budget_callout = budget_callout;
>
> + _ISR_lock_Initialize( &the_thread->Timer.Lock, "Thread Timer" );
> + the_thread->Timer.header = &cpu->Watchdog.Header[
> PER_CPU_WATCHDOG_RELATIVE ];
> + _Watchdog_Preinitialize( &the_thread->Timer.Watchdog, cpu );
> +
> switch ( budget_algorithm ) {
> case THREAD_CPU_BUDGET_ALGORITHM_NONE:
> case THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE:
> diff --git a/cpukit/score/src/threadqenqueue.c
> b/cpukit/score/src/threadqenqueue.c
> index 960783c..07618fc 100644
> --- a/cpukit/score/src/threadqenqueue.c
> +++ b/cpukit/score/src/threadqenqueue.c
> @@ -35,7 +35,7 @@
>
> static void _Thread_queue_Unblock( Thread_Control *the_thread )
> {
> - _Watchdog_Remove_ticks( &the_thread->Timer );
> + _Thread_Timer_remove( the_thread );
> _Thread_Unblock( the_thread );
>
> #if defined(RTEMS_MULTIPROCESSING)
> @@ -84,8 +84,12 @@ void _Thread_queue_Enqueue_critical(
> */
> if ( timeout != WATCHDOG_NO_TIMEOUT ) {
> _Thread_Wait_set_timeout_code( the_thread, timeout_code );
> - _Watchdog_Initialize( &the_thread->Timer, _Thread_Timeout, 0,
> the_thread );
> - _Watchdog_Insert_ticks( &the_thread->Timer, timeout );
> + _Thread_Timer_insert_relative(
> + the_thread,
> + cpu_self,
> + _Thread_Timeout,
> + timeout
> + );
> }
>
> success = _Thread_Wait_flags_try_change(
> diff --git a/cpukit/score/src/threadrestart.c
> b/cpukit/score/src/threadrestart.c
> index 03b1fba..d366f97 100644
> --- a/cpukit/score/src/threadrestart.c
> +++ b/cpukit/score/src/threadrestart.c
> @@ -84,7 +84,7 @@ static void _Thread_Make_zombie( Thread_Control
> *the_thread )
>
> _Thread_Set_state( the_thread, STATES_ZOMBIE );
> _Thread_queue_Extract_with_proxy( the_thread );
> - _Watchdog_Remove_ticks( &the_thread->Timer );
> + _Thread_Timer_remove( the_thread );
>
> _ISR_lock_ISR_disable_and_acquire( &zombies->Lock, &lock_context );
> _Chain_Append_unprotected( &zombies->Chain, &the_thread->Object.Node );
> @@ -191,7 +191,9 @@ static void _Thread_Start_life_change_for_executing(
> Thread_Control *executing
> )
> {
> - _Assert( executing->Timer.state == WATCHDOG_INACTIVE );
> + _Assert(
> + _Watchdog_Get_state( &executing->Timer.Watchdog ) == WATCHDOG_INACTIVE
> + );
> _Assert(
> executing->current_state == STATES_READY
> || executing->current_state == STATES_SUSPENDED
> @@ -246,7 +248,9 @@ void _Thread_Life_action_handler(
> /* Someone deleted us in the mean-time */
> _Thread_Start_life_change_for_executing( executing );
> } else {
> - _Assert( executing->Timer.state == WATCHDOG_INACTIVE );
> + _Assert(
> + _Watchdog_Get_state( &executing->Timer.Watchdog ) ==
> WATCHDOG_INACTIVE
> + );
> _Assert(
> executing->current_state == STATES_READY
> || executing->current_state == STATES_SUSPENDED
> @@ -274,7 +278,7 @@ static void _Thread_Start_life_change(
>
> _Thread_Set_state( the_thread, STATES_RESTARTING );
> _Thread_queue_Extract_with_proxy( the_thread );
> - _Watchdog_Remove_ticks( &the_thread->Timer );
> + _Thread_Timer_remove( the_thread );
> _Thread_Change_priority(
> the_thread,
> priority,
> diff --git a/cpukit/score/src/threadtimeout.c
> b/cpukit/score/src/threadtimeout.c
> index 8ecaebd..59f6bd9 100644
> --- a/cpukit/score/src/threadtimeout.c
> +++ b/cpukit/score/src/threadtimeout.c
> @@ -33,7 +33,7 @@ static void _Thread_Do_timeout( Thread_Control
> *the_thread )
> _Thread_Lock_restore_default( the_thread );
> }
>
> -void _Thread_Timeout( Objects_Id id, void *arg )
> +void _Thread_Timeout( Watchdog_Control *watchdog )
> {
> Thread_Control *the_thread;
> void *thread_lock;
> @@ -41,7 +41,7 @@ void _Thread_Timeout( Objects_Id id, void *arg )
> Thread_Wait_flags wait_flags;
> bool unblock;
>
> - the_thread = arg;
> + the_thread = RTEMS_CONTAINER_OF( watchdog, Thread_Control,
> Timer.Watchdog );
> thread_lock = _Thread_Lock_acquire( the_thread, &lock_context );
>
> wait_flags = _Thread_Wait_flags_get( the_thread );
> diff --git a/cpukit/score/src/watchdog.c b/cpukit/score/src/watchdog.c
> deleted file mode 100644
> index 8d172fb..0000000
> --- a/cpukit/score/src/watchdog.c
> +++ /dev/null
> @@ -1,36 +0,0 @@
> -/**
> - * @file
> - *
> - * @brief Watchdog Handler Initialization
> - * @ingroup ScoreWatchdog
> - */
> -
> -/*
> - * Watchdog Handler
> - *
> - *
> - * COPYRIGHT (c) 1989-1999.
> - * On-Line Applications Research Corporation (OAR).
> - *
> - * The license and distribution terms for this file may be
> - * found in the file LICENSE in this distribution or at
> - * http://www.rtems.org/license/LICENSE.
> - */
> -
> -#if HAVE_CONFIG_H
> -#include "config.h"
> -#endif
> -
> -#include <rtems/score/watchdogimpl.h>
> -
> -Watchdog_Header _Watchdog_Ticks_header;
> -
> -Watchdog_Header _Watchdog_Seconds_header;
> -
> -void _Watchdog_Handler_initialization( void )
> -{
> - _Watchdog_Ticks_since_boot = 0;
> -
> - _Watchdog_Header_initialize( &_Watchdog_Ticks_header );
> - _Watchdog_Header_initialize( &_Watchdog_Seconds_header );
> -}
> diff --git a/cpukit/score/src/watchdogadjust.c
> b/cpukit/score/src/watchdogadjust.c
> deleted file mode 100644
> index 32b5f79..0000000
> --- a/cpukit/score/src/watchdogadjust.c
> +++ /dev/null
> @@ -1,80 +0,0 @@
> -/**
> - * @file
> - *
> - * @brief Watchdog Adjust
> - * @ingroup ScoreWatchdog
> - */
> -
> -/*
> - * COPYRIGHT (c) 1989-1999.
> - * On-Line Applications Research Corporation (OAR).
> - *
> - * The license and distribution terms for this file may be
> - * found in the file LICENSE in this distribution or at
> - * http://www.rtems.org/license/LICENSE.
> - */
> -
> -#if HAVE_CONFIG_H
> -#include "config.h"
> -#endif
> -
> -#include <rtems/score/watchdogimpl.h>
> -
> -void _Watchdog_Adjust_backward_locked(
> - Watchdog_Header *header,
> - Watchdog_Interval units
> -)
> -{
> - if ( !_Watchdog_Is_empty( header ) ) {
> - _Watchdog_First( header )->delta_interval += units;
> - }
> -}
> -
> -void _Watchdog_Adjust_backward(
> - Watchdog_Header *header,
> - Watchdog_Interval units
> -)
> -{
> - ISR_lock_Context lock_context;
> -
> - _Watchdog_Acquire( header, &lock_context );
> - _Watchdog_Adjust_backward_locked( header, units );
> - _Watchdog_Release( header, &lock_context );
> -}
> -
> -void _Watchdog_Adjust_forward_locked(
> - Watchdog_Header *header,
> - Watchdog_Interval units,
> - ISR_lock_Context *lock_context
> -)
> -{
> - while ( !_Watchdog_Is_empty( header ) && units > 0 ) {
> - Watchdog_Control *first = _Watchdog_First( header );
> -
> - if ( units < first->delta_interval ) {
> - first->delta_interval -= units;
> - break;
> - } else {
> - units -= first->delta_interval;
> - first->delta_interval = 1;
> -
> - _Watchdog_Release( header, lock_context );
> -
> - _Watchdog_Tickle( header );
> -
> - _Watchdog_Acquire( header, lock_context );
> - }
> - }
> -}
> -
> -void _Watchdog_Adjust_forward(
> - Watchdog_Header *header,
> - Watchdog_Interval units
> -)
> -{
> - ISR_lock_Context lock_context;
> -
> - _Watchdog_Acquire( header, &lock_context );
> - _Watchdog_Adjust_forward_locked( header, units, &lock_context );
> - _Watchdog_Release( header, &lock_context );
> -}
> diff --git a/cpukit/score/src/watchdoginsert.c
> b/cpukit/score/src/watchdoginsert.c
> index db15f55..22fc7a5 100644
> --- a/cpukit/score/src/watchdoginsert.c
> +++ b/cpukit/score/src/watchdoginsert.c
> @@ -1,17 +1,22 @@
> /**
> - * @file
> + * @file
> *
> * @brief Watchdog Insert
> * @ingroup ScoreWatchdog
> */
> -
> +
> /*
> - * COPYRIGHT (c) 1989-1999.
> - * On-Line Applications Research Corporation (OAR).
> + * Copyright (c) 2016 embedded brains GmbH. All rights reserved.
> + *
> + * embedded brains GmbH
> + * Dornierstr. 4
> + * 82178 Puchheim
> + * Germany
> + * <rtems at embedded-brains.de>
> *
> - * The license and distribution terms for this file may be
> - * found in the file LICENSE in this distribution or at
> - * http://www.rtems.org/license/LICENSE.
> + * The license and distribution terms for this file may be
> + * found in the file LICENSE in this distribution or at
> + * http://www.rtems.org/license/LICENSE.
> */
>
> #if HAVE_CONFIG_H
> @@ -20,106 +25,41 @@
>
> #include <rtems/score/watchdogimpl.h>
>
> -static void _Watchdog_Insert_fixup(
> - Watchdog_Header *header,
> - Watchdog_Control *the_watchdog,
> - Watchdog_Interval delta,
> - Watchdog_Control *next_watchdog,
> - Watchdog_Interval delta_next
> -)
> -{
> - const Chain_Node *iterator_tail;
> - Chain_Node *iterator_node;
> -
> - next_watchdog->delta_interval = delta_next - delta;
> -
> - iterator_node = _Chain_First( &header->Iterators );
> - iterator_tail = _Chain_Immutable_tail( &header->Iterators );
> -
> - while ( iterator_node != iterator_tail ) {
> - Watchdog_Iterator *iterator;
> -
> - iterator = (Watchdog_Iterator *) iterator_node;
> -
> - if ( iterator->current == &next_watchdog->Node ) {
> - iterator->current = &the_watchdog->Node;
> - }
> -
> - iterator_node = _Chain_Next( iterator_node );
> - }
> -}
> -
> -void _Watchdog_Insert_locked(
> +void _Watchdog_Insert(
> Watchdog_Header *header,
> Watchdog_Control *the_watchdog,
> - ISR_lock_Context *lock_context
> + uint64_t expire
> )
> {
> - if ( the_watchdog->state == WATCHDOG_INACTIVE ) {
> - Watchdog_Iterator iterator;
> - Chain_Node *current;
> - Chain_Node *next;
> - Watchdog_Interval delta;
> -
> - the_watchdog->state = WATCHDOG_BEING_INSERTED;
> -
> - _Chain_Append_unprotected( &header->Iterators, &iterator.Node );
> -
> - delta = the_watchdog->initial;
> - current = _Chain_Head( &header->Watchdogs );
> + RBTree_Node **link;
> + RBTree_Node *parent;
> + RBTree_Node *old_first;
> + RBTree_Node *new_first;
>
> - while (
> - ( next = _Chain_Next( current ) ) != _Chain_Tail(
> &header->Watchdogs )
> - ) {
> - Watchdog_Control *next_watchdog;
> - Watchdog_Interval delta_next;
> + _Assert( _Watchdog_Get_state( the_watchdog ) == WATCHDOG_INACTIVE );
>
> - next_watchdog = (Watchdog_Control *) next;
> - delta_next = next_watchdog->delta_interval;
> + link = _RBTree_Root_reference( &header->Watchdogs );
> + parent = NULL;
> + old_first = header->first;
> + new_first = &the_watchdog->Node.RBTree;
>
> - if ( delta < delta_next ) {
> - _Watchdog_Insert_fixup(
> - header,
> - the_watchdog,
> - delta,
> - next_watchdog,
> - delta_next
> - );
> - break;
> - }
> + the_watchdog->expire = expire;
>
> - iterator.delta_interval = delta - delta_next;
> - iterator.current = next;
> + while ( *link != NULL ) {
> + Watchdog_Control *parent_watchdog;
>
> - _Watchdog_Flash( header, lock_context );
> + parent = *link;
> + parent_watchdog = (Watchdog_Control *) parent;
>
> - if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) {
> - goto abort_insert;
> - }
> -
> - delta = iterator.delta_interval;
> - current = iterator.current;
> + if ( expire < parent_watchdog->expire ) {
> + link = _RBTree_Left_reference( parent );
> + } else {
> + link = _RBTree_Right_reference( parent );
> + new_first = old_first;
> }
> -
> - the_watchdog->delta_interval = delta;
> - the_watchdog->start_time = _Watchdog_Ticks_since_boot;
> - _Watchdog_Activate( the_watchdog );
> - _Chain_Insert_unprotected( current, &the_watchdog->Node );
> -
> -abort_insert:
> -
> - _Chain_Extract_unprotected( &iterator.Node );
> }
> -}
> -
> -void _Watchdog_Insert(
> - Watchdog_Header *header,
> - Watchdog_Control *the_watchdog
> -)
> -{
> - ISR_lock_Context lock_context;
>
> - _Watchdog_Acquire( header, &lock_context );
> - _Watchdog_Insert_locked( header, the_watchdog, &lock_context );
> - _Watchdog_Release( header, &lock_context );
> + header->first = new_first;
> + _RBTree_Add_child( &the_watchdog->Node.RBTree, parent, link );
> + _RBTree_Insert_color( &header->Watchdogs, &the_watchdog->Node.RBTree );
> }
> diff --git a/cpukit/score/src/watchdogremove.c
> b/cpukit/score/src/watchdogremove.c
> index 2aa72a4..2605a67 100644
> --- a/cpukit/score/src/watchdogremove.c
> +++ b/cpukit/score/src/watchdogremove.c
> @@ -1,17 +1,22 @@
> /**
> * @file
> *
> - * @brief Remove Watchdog from List
> + * @brief Remove Watchdog
> * @ingroup ScoreWatchdog
> */
>
> /*
> - * COPYRIGHT (c) 1989-1999.
> - * On-Line Applications Research Corporation (OAR).
> + * Copyright (c) 2016 embedded brains GmbH. All rights reserved.
> *
> - * The license and distribution terms for this file may be
> - * found in the file LICENSE in this distribution or at
> - * http://www.rtems.org/license/LICENSE.
> + * embedded brains GmbH
> + * Dornierstr. 4
> + * 82178 Puchheim
> + * Germany
> + * <rtems at embedded-brains.de>
> + *
> + * The license and distribution terms for this file may be
> + * found in the file LICENSE in this distribution or at
> + * http://www.rtems.org/license/LICENSE.
> */
>
> #if HAVE_CONFIG_H
> @@ -19,161 +24,18 @@
> #endif
>
> #include <rtems/score/watchdogimpl.h>
> -#include <rtems/score/assert.h>
> -
> -static void _Watchdog_Remove_it(
> - Watchdog_Header *header,
> - Watchdog_Control *the_watchdog
> -)
> -{
> - Chain_Node *next;
> - Watchdog_Interval delta;
> - const Chain_Node *iterator_tail;
> - Chain_Node *iterator_node;
> -
> - _Assert( the_watchdog->state == WATCHDOG_ACTIVE );
> -
> - the_watchdog->state = WATCHDOG_INACTIVE;
> - the_watchdog->stop_time = _Watchdog_Ticks_since_boot;
> -
> - next = _Chain_Next( &the_watchdog->Node );
> - delta = the_watchdog->delta_interval;
> -
> - if ( next != _Chain_Tail( &header->Watchdogs ) ) {
> - Watchdog_Control *next_watchdog;
> -
> - next_watchdog = (Watchdog_Control *) next;
> - next_watchdog->delta_interval += delta;
> - }
> -
> - _Chain_Extract_unprotected( &the_watchdog->Node );
> -
> - iterator_node = _Chain_First( &header->Iterators );
> - iterator_tail = _Chain_Immutable_tail( &header->Iterators );
> -
> - while ( iterator_node != iterator_tail ) {
> - Watchdog_Iterator *iterator;
> -
> - iterator = (Watchdog_Iterator *) iterator_node;
> -
> - if ( iterator->current == next ) {
> - iterator->delta_interval += delta;
> - }
> -
> - if ( iterator->current == &the_watchdog->Node ) {
> - Chain_Node *previous = _Chain_Previous( &the_watchdog->Node );
> -
> - iterator->current = previous;
> -
> - if ( previous != _Chain_Head( &header->Watchdogs ) ) {
> - Watchdog_Control *previous_watchdog;
> -
> - previous_watchdog = (Watchdog_Control *) previous;
> - iterator->delta_interval += previous_watchdog->delta_interval;
> - }
> - }
> -
> - iterator_node = _Chain_Next( iterator_node );
> - }
> -}
>
> -Watchdog_States _Watchdog_Remove(
> +void _Watchdog_Remove(
> Watchdog_Header *header,
> Watchdog_Control *the_watchdog
> )
> {
> - ISR_lock_Context lock_context;
> - Watchdog_States previous_state;
> - Watchdog_Interval now;
> -
> - _Watchdog_Acquire( header, &lock_context );
> - previous_state = the_watchdog->state;
> - switch ( previous_state ) {
> - case WATCHDOG_INACTIVE:
> - break;
> -
> - case WATCHDOG_BEING_INSERTED:
> -
> - /*
> - * It is not actually on the chain so just change the state and
> - * the Insert operation we interrupted will be aborted.
> - */
> - the_watchdog->state = WATCHDOG_INACTIVE;
> - now = _Watchdog_Ticks_since_boot;
> - the_watchdog->start_time = now;
> - the_watchdog->stop_time = now;
> - break;
> -
> - case WATCHDOG_ACTIVE:
> - _Watchdog_Remove_it( header, the_watchdog );
> - break;
> - }
> -
> - _Watchdog_Release( header, &lock_context );
> - return( previous_state );
> -}
> -
> -void _Watchdog_Tickle(
> - Watchdog_Header *header
> -)
> -{
> - ISR_lock_Context lock_context;
> -
> - _Watchdog_Acquire( header, &lock_context );
> -
> - if ( !_Watchdog_Is_empty( header ) ) {
> - Watchdog_Control *first;
> - Watchdog_Interval delta;
> -
> - first = _Watchdog_First( header );
> - delta = first->delta_interval;
> -
> - /*
> - * Although it is forbidden to insert watchdogs with a delta interval
> of
> - * zero it is possible to observe watchdogs with a delta interval of
> zero
> - * at this point. For example lets have a watchdog chain of one
> watchdog
> - * with a delta interval of one and insert a new one with an initial
> value
> - * of one. At the start of the insert procedure it will advance one
> step
> - * and reduce its delta interval by one yielding zero. Now a tick
> happens.
> - * This will remove the watchdog on the chain and update the insert
> - * iterator. Now the insert operation continues and will insert the
> new
> - * watchdog with a delta interval of zero.
> - */
> - if ( delta > 0 ) {
> - --delta;
> - first->delta_interval = delta;
> + if ( _Watchdog_Is_scheduled( the_watchdog ) ) {
> + if ( header->first == &the_watchdog->Node.RBTree ) {
> + _Watchdog_Next_first( header, the_watchdog );
> }
>
> - while ( delta == 0 ) {
> - bool run;
> - Watchdog_Service_routine_entry routine;
> - Objects_Id id;
> - void *user_data;
> -
> - run = ( first->state == WATCHDOG_ACTIVE );
> -
> - _Watchdog_Remove_it( header, first );
> -
> - routine = first->routine;
> - id = first->id;
> - user_data = first->user_data;
> -
> - _Watchdog_Release( header, &lock_context );
> -
> - if ( run ) {
> - (*routine)( id, user_data );
> - }
> -
> - _Watchdog_Acquire( header, &lock_context );
> -
> - if ( _Watchdog_Is_empty( header ) ) {
> - break;
> - }
> -
> - first = _Watchdog_First( header );
> - delta = first->delta_interval;
> - }
> + _RBTree_Extract( &header->Watchdogs, &the_watchdog->Node.RBTree );
> + _Watchdog_Set_state( the_watchdog, WATCHDOG_INACTIVE );
> }
> -
> - _Watchdog_Release( header, &lock_context );
> }
> diff --git a/cpukit/score/src/watchdogtick.c
> b/cpukit/score/src/watchdogtick.c
> index e89c088..ab7eadc 100644
> --- a/cpukit/score/src/watchdogtick.c
> +++ b/cpukit/score/src/watchdogtick.c
> @@ -1,5 +1,5 @@
> /*
> - * Copyright (c) 2015 embedded brains GmbH. All rights reserved.
> + * Copyright (c) 2015, 2016 embedded brains GmbH. All rights reserved.
> *
> * embedded brains GmbH
> * Dornierstr. 4
> @@ -12,25 +12,81 @@
> * http://www.rtems.org/license/LICENSE.
> */
>
> -#include <rtems/score/assert.h>
> +#if HAVE_CONFIG_H
> +#include "config.h"
> +#endif
> +
> +#include <rtems/score/watchdogimpl.h>
> #include <rtems/score/schedulerimpl.h>
> #include <rtems/score/threaddispatch.h>
> -#include <rtems/score/todimpl.h>
> -#include <rtems/score/watchdogimpl.h>
> +#include <rtems/score/timecounter.h>
>
> -#if HAVE_CONFIG_H
> -#include "config.h"
> +void _Watchdog_Do_tickle(
> + Watchdog_Header *header,
> + uint64_t now,
> +#ifdef RTEMS_SMP
> + ISR_lock_Control *lock,
> #endif
> + ISR_lock_Context *lock_context
> +)
> +{
> + while ( true ) {
> + Watchdog_Control *the_watchdog;
> +
> + the_watchdog = (Watchdog_Control *) header->first;
> +
> + if ( the_watchdog == NULL ) {
> + break;
> + }
> +
> + if ( the_watchdog->expire <= now ) {
> + Watchdog_Service_routine_entry routine;
> +
> + _Watchdog_Next_first( header, the_watchdog );
> + _RBTree_Extract( &header->Watchdogs, &the_watchdog->Node.RBTree );
> + _Watchdog_Set_state( the_watchdog, WATCHDOG_INACTIVE );
> + routine = the_watchdog->routine;
> +
> + _ISR_lock_Release_and_ISR_enable( lock, lock_context );
> + ( *routine )( the_watchdog );
> + _ISR_lock_ISR_disable_and_acquire( lock, lock_context );
> + } else {
> + break;
> + }
> + }
> +
> + _ISR_lock_Release_and_ISR_enable( lock, lock_context );
> +}
>
> void _Watchdog_Tick( Per_CPU_Control *cpu )
> {
> - _Assert( !_Thread_Dispatch_is_enabled() );
> + ISR_lock_Context lock_context;
> + uint64_t ticks;
> + struct timespec now;
>
> if ( _Per_CPU_Is_boot_processor( cpu ) ) {
> - _TOD_Tickle_ticks();
> + ++_Watchdog_Ticks_since_boot;
> + }
>
> - _Watchdog_Tickle_ticks();
> + _ISR_lock_ISR_disable_and_acquire( &cpu->Watchdog.Lock, &lock_context );
>
> - _Scheduler_Tick();
> - }
> + ticks = cpu->Watchdog.ticks;
> + _Assert( ticks < UINT64_MAX );
> + ++ticks;
> + cpu->Watchdog.ticks = ticks;
> +
> + _Watchdog_Tickle(
> + &cpu->Watchdog.Header[ PER_CPU_WATCHDOG_RELATIVE ],
> + ticks,
> + &cpu->Watchdog.Lock,
> + &lock_context
> + );
> +
> + _Timecounter_Getnanotime( &now );
> + _Watchdog_Per_CPU_tickle_absolute(
> + cpu,
> + _Watchdog_Ticks_from_timespec( &now )
> + );
> +
> + _Scheduler_Tick( cpu );
> }
> diff --git a/testsuites/smptests/Makefile.am
> b/testsuites/smptests/Makefile.am
> index 92f4528..610f313 100644
> --- a/testsuites/smptests/Makefile.am
> +++ b/testsuites/smptests/Makefile.am
> @@ -14,6 +14,7 @@ SUBDIRS += smpatomic01
> SUBDIRS += smpcache01
> SUBDIRS += smpcapture01
> SUBDIRS += smpcapture02
> +SUBDIRS += smpclock01
> SUBDIRS += smpfatal01
> SUBDIRS += smpfatal02
> SUBDIRS += smpfatal03
> diff --git a/testsuites/smptests/configure.ac b/testsuites/smptests/
> configure.ac
> index 27e8f9c..a89b796 100644
> --- a/testsuites/smptests/configure.ac
> +++ b/testsuites/smptests/configure.ac
> @@ -69,6 +69,7 @@ smpatomic01/Makefile
> smpcache01/Makefile
> smpcapture01/Makefile
> smpcapture02/Makefile
> +smpclock01/Makefile
> smpfatal01/Makefile
> smpfatal02/Makefile
> smpfatal03/Makefile
> diff --git a/testsuites/smptests/smpclock01/Makefile.am
> b/testsuites/smptests/smpclock01/Makefile.am
> new file mode 100644
> index 0000000..49e274b
> --- /dev/null
> +++ b/testsuites/smptests/smpclock01/Makefile.am
> @@ -0,0 +1,20 @@
> +rtems_tests_PROGRAMS = smpclock01
> +smpclock01_SOURCES = init.c
> +smpclock01_SOURCES += ../../support/src/spin.c
> +
> +dist_rtems_tests_DATA = smpclock01.scn smpclock01.doc
> +
> +include $(RTEMS_ROOT)/make/custom/@RTEMS_BSP at .cfg
> +include $(top_srcdir)/../automake/compile.am
> +include $(top_srcdir)/../automake/leaf.am
> +
> +AM_CPPFLAGS += -I$(top_srcdir)/../support/include
> +
> +LINK_OBJS = $(smpclock01_OBJECTS)
> +LINK_LIBS = $(smpclock01_LDLIBS)
> +
> +smpclock01$(EXEEXT): $(smpclock01_OBJECTS) $(smpclock01_DEPENDENCIES)
> + @rm -f smpclock01$(EXEEXT)
> + $(make-exe)
> +
> +include $(top_srcdir)/../automake/local.am
> diff --git a/testsuites/smptests/smpclock01/init.c
> b/testsuites/smptests/smpclock01/init.c
> new file mode 100644
> index 0000000..36016ef
> --- /dev/null
> +++ b/testsuites/smptests/smpclock01/init.c
> @@ -0,0 +1,206 @@
> +/*
> + * Copyright (c) 2016 embedded brains GmbH. All rights reserved.
> + *
> + * embedded brains GmbH
> + * Dornierstr. 4
> + * 82178 Puchheim
> + * Germany
> + * <rtems at embedded-brains.de>
> + *
> + * The license and distribution terms for this file may be
> + * found in the file LICENSE in this distribution or at
> + * http://www.rtems.org/license/LICENSE.
> + */
> +
> +#ifdef HAVE_CONFIG_H
> + #include "config.h"
> +#endif
> +
> +#include "tmacros.h"
> +
> +#include <rtems.h>
> +#include <rtems/libcsupport.h>
> +#include <rtems/score/percpu.h>
> +#include <rtems/score/smpbarrier.h>
> +
> +#include <test_support.h>
> +
> +#define CPU_COUNT 2
> +
> +#define SCHEDULER_A rtems_build_name(' ', ' ', ' ', 'A')
> +
> +#define SCHEDULER_B rtems_build_name(' ', ' ', ' ', 'B')
> +
> +const char rtems_test_name[] = "SMPCLOCK 1";
> +
> +typedef struct {
> + SMP_barrier_Control barrier;
> + SMP_barrier_State delay_barrier_state;
> + SMP_barrier_State timer_barrier_state;
> +} test_context;
> +
> +static test_context test_instance = {
> + .barrier = SMP_BARRIER_CONTROL_INITIALIZER,
> + .delay_barrier_state = SMP_BARRIER_STATE_INITIALIZER,
> + .timer_barrier_state = SMP_BARRIER_STATE_INITIALIZER
> +};
> +
> +static void wait(test_context *ctx, SMP_barrier_State *bs)
> +{
> + _SMP_barrier_Wait(&ctx->barrier, bs, CPU_COUNT);
> +}
> +
> +static void timer_isr(rtems_id id, void *arg)
> +{
> + test_context *ctx = arg;
> +
> + /* (B) */
> + wait(ctx, &ctx->timer_barrier_state);
> +}
> +
> +static void timer_task(rtems_task_argument arg)
> +{
> + test_context *ctx = (test_context *) arg;
> + rtems_status_code sc;
> + rtems_id timer_id;
> +
> + rtems_test_assert(rtems_get_current_processor() == 1);
> +
> + sc = rtems_timer_create(SCHEDULER_B, &timer_id);
> + rtems_test_assert(sc == RTEMS_SUCCESSFUL);
> +
> + /* (A) */
> + wait(ctx, &ctx->timer_barrier_state);
> +
> + sc = rtems_timer_fire_after(timer_id, 1, timer_isr, ctx);
> + rtems_test_assert(sc == RTEMS_SUCCESSFUL);
> +
> + sc = rtems_task_wake_after(1);
> + rtems_test_assert(sc == RTEMS_SUCCESSFUL);
> +
> + sc = rtems_timer_delete(timer_id);
> + rtems_test_assert(sc == RTEMS_SUCCESSFUL);
> +
> + /* (C) */
> + wait(ctx, &ctx->timer_barrier_state);
> +
> + while (true) {
> + /* Wait for deletion */
> + }
> +}
> +
> +static void delay_clock_tick(test_context *ctx)
> +{
> + rtems_interrupt_level level;
> + const Per_CPU_Control *cpu_self = _Per_CPU_Get_by_index(0);
> + const Per_CPU_Control *cpu_other = _Per_CPU_Get_by_index(1);
> + uint64_t ticks;
> +
> + rtems_test_assert(rtems_get_current_processor() == 0);
> +
> + rtems_test_spin_until_next_tick();
> + ticks = cpu_self->Watchdog.ticks;
> +
> + rtems_interrupt_local_disable(level);
> +
> + /* (A) */
> + wait(ctx, &ctx->delay_barrier_state);
> +
> + /* (B) */
> + wait(ctx, &ctx->delay_barrier_state);
> +
> + rtems_test_assert(cpu_self->Watchdog.ticks == ticks);
> + rtems_test_assert(cpu_other->Watchdog.ticks == ticks + 1);
> +
> + rtems_interrupt_local_enable(level);
> +
> + rtems_test_assert(cpu_self->Watchdog.ticks == ticks + 1);
> + rtems_test_assert(cpu_other->Watchdog.ticks == ticks + 1);
> +
> + /* (C) */
> + wait(ctx, &ctx->delay_barrier_state);
> +}
> +
> +static void test(void)
> +{
> + test_context *ctx = &test_instance;
> + rtems_status_code sc;
> + rtems_id scheduler_b_id;
> + rtems_id task_id;
> +
> + sc = rtems_scheduler_ident(SCHEDULER_B, &scheduler_b_id);
> + rtems_test_assert(sc == RTEMS_SUCCESSFUL);
> +
> + sc = rtems_task_create(
> + SCHEDULER_B,
> + 1,
> + RTEMS_MINIMUM_STACK_SIZE,
> + RTEMS_DEFAULT_MODES,
> + RTEMS_DEFAULT_ATTRIBUTES,
> + &task_id
> + );
> + rtems_test_assert(sc == RTEMS_SUCCESSFUL);
> +
> + sc = rtems_task_set_scheduler(task_id, scheduler_b_id);
> + rtems_test_assert(sc == RTEMS_SUCCESSFUL);
> +
> + sc = rtems_task_start(task_id, timer_task, (rtems_task_argument) ctx);
> + rtems_test_assert(sc == RTEMS_SUCCESSFUL);
> +
> + delay_clock_tick(ctx);
> +
> + sc = rtems_task_delete(task_id);
> + rtems_test_assert(sc == RTEMS_SUCCESSFUL);
> +}
> +
> +static void Init(rtems_task_argument arg)
> +{
> + rtems_resource_snapshot snapshot;
> +
> + TEST_BEGIN();
> +
> + rtems_resource_snapshot_take(&snapshot);
> +
> + if (rtems_get_processor_count() == CPU_COUNT) {
> + test();
> + }
> +
> + rtems_test_assert(rtems_resource_snapshot_check(&snapshot));
> +
> + TEST_END();
> + rtems_test_exit(0);
> +}
> +
> +#define CONFIGURE_APPLICATION_NEEDS_CLOCK_DRIVER
> +#define CONFIGURE_APPLICATION_NEEDS_CONSOLE_DRIVER
> +
> +#define CONFIGURE_SMP_APPLICATION
> +
> +#define CONFIGURE_SMP_MAXIMUM_PROCESSORS CPU_COUNT
> +
> +#define CONFIGURE_SCHEDULER_SIMPLE_SMP
> +
> +#include <rtems/scheduler.h>
> +
> +RTEMS_SCHEDULER_CONTEXT_SIMPLE_SMP(a);
> +RTEMS_SCHEDULER_CONTEXT_SIMPLE_SMP(b);
> +
> +#define CONFIGURE_SCHEDULER_CONTROLS \
> + RTEMS_SCHEDULER_CONTROL_SIMPLE_SMP(a, SCHEDULER_A), \
> + RTEMS_SCHEDULER_CONTROL_SIMPLE_SMP(b, SCHEDULER_B)
> +
> +#define CONFIGURE_SMP_SCHEDULER_ASSIGNMENTS \
> + RTEMS_SCHEDULER_ASSIGN(0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_MANDATORY), \
> + RTEMS_SCHEDULER_ASSIGN(1, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL)
> +
> +#define CONFIGURE_MAXIMUM_TASKS CPU_COUNT
> +
> +#define CONFIGURE_MAXIMUM_TIMERS 1
> +
> +#define CONFIGURE_INITIAL_EXTENSIONS RTEMS_TEST_INITIAL_EXTENSION
> +
> +#define CONFIGURE_RTEMS_INIT_TASKS_TABLE
> +
> +#define CONFIGURE_INIT
> +
> +#include <rtems/confdefs.h>
> diff --git a/testsuites/smptests/smpclock01/smpclock01.doc
> b/testsuites/smptests/smpclock01/smpclock01.doc
> new file mode 100644
> index 0000000..130644a
> --- /dev/null
> +++ b/testsuites/smptests/smpclock01/smpclock01.doc
> @@ -0,0 +1,11 @@
> +This file describes the directives and concepts tested by this test set.
> +
> +test set name: smpclock01
> +
> +directives:
> +
> + - Clock driver interrupt
> +
> +concepts:
> +
> + - Ensures that the clock interrupt is distributed to all online
> processors.
> diff --git a/testsuites/smptests/smpclock01/smpclock01.scn
> b/testsuites/smptests/smpclock01/smpclock01.scn
> new file mode 100644
> index 0000000..192ed83
> --- /dev/null
> +++ b/testsuites/smptests/smpclock01/smpclock01.scn
> @@ -0,0 +1,2 @@
> +*** BEGIN OF TEST SMPCLOCK 1 ***
> +*** END OF TEST SMPCLOCK 1 ***
> diff --git a/testsuites/smptests/smpwakeafter01/smpwakeafter01.scn
> b/testsuites/smptests/smpwakeafter01/smpwakeafter01.scn
> index 9bbb558..7fa203d 100644
> --- a/testsuites/smptests/smpwakeafter01/smpwakeafter01.scn
> +++ b/testsuites/smptests/smpwakeafter01/smpwakeafter01.scn
> @@ -9,36 +9,196 @@
> 3 seconds remaining
> 2 seconds remaining
> 1 seconds remaining
> -counts[0][0] = 15479
> -counts[0][1] = 17039
> -counts[0][2] = 12389
> -counts[0][3] = 8077
> -counts[0][4] = 3
> -counts[0][5] = 2431
> -counts[0][6] = 2630
> -counts[0][7] = 2128
> -counts[1][0] = 15461
> -counts[1][1] = 16813
> -counts[1][2] = 12248
> -counts[1][3] = 7483
> -counts[1][4] = 5499
> -counts[1][5] = 3170
> -counts[1][6] = 2549
> -counts[1][7] = 1748
> -counts[2][0] = 71
> -counts[2][1] = 17068
> -counts[2][2] = 7661
> -counts[2][3] = 8190
> -counts[2][4] = 5513
> -counts[2][5] = 3864
> -counts[2][6] = 1454
> -counts[2][7] = 1993
> -counts[3][0] = 14511
> -counts[3][1] = 16115
> -counts[3][2] = 12561
> -counts[3][3] = 7281
> -counts[3][4] = 5507
> -counts[3][5] = 3828
> -counts[3][6] = 2687
> -counts[3][7] = 1278
> +counts[0][0] = 10013
> +counts[0][1] = 5007
> +counts[0][2] = 3339
> +counts[0][3] = 2004
> +counts[0][4] = 1432
> +counts[0][5] = 912
> +counts[0][6] = 771
> +counts[0][7] = 590
> +counts[1][0] = 10027
> +counts[1][1] = 5015
> +counts[1][2] = 3344
> +counts[1][3] = 2007
> +counts[1][4] = 1434
> +counts[1][5] = 913
> +counts[1][6] = 773
> +counts[1][7] = 591
> +counts[2][0] = 10041
> +counts[2][1] = 5022
> +counts[2][2] = 3349
> +counts[2][3] = 2010
> +counts[2][4] = 1436
> +counts[2][5] = 914
> +counts[2][6] = 774
> +counts[2][7] = 592
> +counts[3][0] = 10055
> +counts[3][1] = 5029
> +counts[3][2] = 3353
> +counts[3][3] = 2013
> +counts[3][4] = 1438
> +counts[3][5] = 915
> +counts[3][6] = 775
> +counts[3][7] = 593
> +counts[4][0] = 10070
> +counts[4][1] = 5036
> +counts[4][2] = 3358
> +counts[4][3] = 2015
> +counts[4][4] = 1440
> +counts[4][5] = 917
> +counts[4][6] = 776
> +counts[4][7] = 594
> +counts[5][0] = 10084
> +counts[5][1] = 5043
> +counts[5][2] = 3363
> +counts[5][3] = 2018
> +counts[5][4] = 1442
> +counts[5][5] = 918
> +counts[5][6] = 777
> +counts[5][7] = 594
> +counts[6][0] = 10098
> +counts[6][1] = 5050
> +counts[6][2] = 3368
> +counts[6][3] = 2021
> +counts[6][4] = 1444
> +counts[6][5] = 919
> +counts[6][6] = 778
> +counts[6][7] = 595
> +counts[7][0] = 10113
> +counts[7][1] = 5058
> +counts[7][2] = 3373
> +counts[7][3] = 2024
> +counts[7][4] = 1446
> +counts[7][5] = 921
> +counts[7][6] = 779
> +counts[7][7] = 596
> +counts[8][0] = 10127
> +counts[8][1] = 5065
> +counts[8][2] = 3377
> +counts[8][3] = 2027
> +counts[8][4] = 1448
> +counts[8][5] = 922
> +counts[8][6] = 780
> +counts[8][7] = 597
> +counts[9][0] = 10142
> +counts[9][1] = 5072
> +counts[9][2] = 3382
> +counts[9][3] = 2030
> +counts[9][4] = 1450
> +counts[9][5] = 923
> +counts[9][6] = 781
> +counts[9][7] = 598
> +counts[10][0] = 10156
> +counts[10][1] = 5079
> +counts[10][2] = 3387
> +counts[10][3] = 2033
> +counts[10][4] = 1452
> +counts[10][5] = 925
> +counts[10][6] = 783
> +counts[10][7] = 599
> +counts[11][0] = 10170
> +counts[11][1] = 5086
> +counts[11][2] = 3392
> +counts[11][3] = 2036
> +counts[11][4] = 1454
> +counts[11][5] = 926
> +counts[11][6] = 784
> +counts[11][7] = 599
> +counts[12][0] = 10185
> +counts[12][1] = 5094
> +counts[12][2] = 3397
> +counts[12][3] = 2039
> +counts[12][4] = 1457
> +counts[12][5] = 927
> +counts[12][6] = 785
> +counts[12][7] = 600
> +counts[13][0] = 10200
> +counts[13][1] = 5101
> +counts[13][2] = 3402
> +counts[13][3] = 2042
> +counts[13][4] = 1459
> +counts[13][5] = 929
> +counts[13][6] = 786
> +counts[13][7] = 601
> +counts[14][0] = 10215
> +counts[14][1] = 5109
> +counts[14][2] = 3407
> +counts[14][3] = 2045
> +counts[14][4] = 1461
> +counts[14][5] = 930
> +counts[14][6] = 787
> +counts[14][7] = 602
> +counts[15][0] = 10230
> +counts[15][1] = 5116
> +counts[15][2] = 3412
> +counts[15][3] = 2048
> +counts[15][4] = 1463
> +counts[15][5] = 931
> +counts[15][6] = 788
> +counts[15][7] = 603
> +counts[16][0] = 10245
> +counts[16][1] = 5124
> +counts[16][2] = 3417
> +counts[16][3] = 2051
> +counts[16][4] = 1465
> +counts[16][5] = 933
> +counts[16][6] = 789
> +counts[16][7] = 604
> +counts[17][0] = 10260
> +counts[17][1] = 5131
> +counts[17][2] = 3422
> +counts[17][3] = 2054
> +counts[17][4] = 1467
> +counts[17][5] = 934
> +counts[17][6] = 791
> +counts[17][7] = 605
> +counts[18][0] = 10275
> +counts[18][1] = 5139
> +counts[18][2] = 3427
> +counts[18][3] = 2057
> +counts[18][4] = 1469
> +counts[18][5] = 935
> +counts[18][6] = 792
> +counts[18][7] = 606
> +counts[19][0] = 10290
> +counts[19][1] = 5146
> +counts[19][2] = 3432
> +counts[19][3] = 2060
> +counts[19][4] = 1472
> +counts[19][5] = 937
> +counts[19][6] = 793
> +counts[19][7] = 607
> +counts[20][0] = 10305
> +counts[20][1] = 5154
> +counts[20][2] = 3437
> +counts[20][3] = 2063
> +counts[20][4] = 1474
> +counts[20][5] = 938
> +counts[20][6] = 794
> +counts[20][7] = 607
> +counts[21][0] = 10320
> +counts[21][1] = 5161
> +counts[21][2] = 3442
> +counts[21][3] = 2066
> +counts[21][4] = 1476
> +counts[21][5] = 940
> +counts[21][6] = 795
> +counts[21][7] = 608
> +counts[22][0] = 10335
> +counts[22][1] = 5169
> +counts[22][2] = 3447
> +counts[22][3] = 2069
> +counts[22][4] = 1478
> +counts[22][5] = 941
> +counts[22][6] = 796
> +counts[22][7] = 609
> +counts[23][0] = 10350
> +counts[23][1] = 5176
> +counts[23][2] = 3452
> +counts[23][3] = 2072
> +counts[23][4] = 1480
> +counts[23][5] = 942
> +counts[23][6] = 798
> +counts[23][7] = 610
> *** END OF TEST SMPWAKEAFTER 1 ***
> diff --git a/testsuites/sptests/Makefile.am
> b/testsuites/sptests/Makefile.am
> index c5210a5..43f3d82 100644
> --- a/testsuites/sptests/Makefile.am
> +++ b/testsuites/sptests/Makefile.am
> @@ -25,7 +25,7 @@ _SUBDIRS = \
> spintrcritical05 spintrcritical06 spintrcritical07 spintrcritical08 \
> spintrcritical09 spintrcritical10 spintrcritical11 spintrcritical12 \
> spintrcritical13 spintrcritical14 spintrcritical15 spintrcritical16 \
> - spintrcritical17 spintrcritical18 spmkdir spmountmgr01 spheapprot \
> + spintrcritical18 spmkdir spmountmgr01 spheapprot \
> sppagesize spsem01 spsem02 spsimplesched01 spsimplesched02 \
> spsimplesched03 spnsext01 spedfsched01 spedfsched02 spedfsched03 \
> spcbssched01 spcbssched02 spcbssched03 spqreslib sptimespec01 \
> @@ -77,6 +77,7 @@ _SUBDIRS += speventsystem01
> _SUBDIRS += spinternalerror01
> _SUBDIRS += spinternalerror02
> _SUBDIRS += sptimer_err01 sptimer_err02
> +_SUBDIRS += sptimerserver01
> _SUBDIRS += spclock_err02
>
> if HAS_CPUSET
> diff --git a/testsuites/sptests/configure.ac b/testsuites/sptests/
> configure.ac
> index e46f6fa..eeebc91 100644
> --- a/testsuites/sptests/configure.ac
> +++ b/testsuites/sptests/configure.ac
> @@ -46,6 +46,7 @@ AM_CONDITIONAL(HAS_SMP,test "$rtems_cv_RTEMS_SMP" =
> "yes")
>
> # Explicitly list all Makefiles here
> AC_CONFIG_FILES([Makefile
> +sptimerserver01/Makefile
> spsysinit01/Makefile
> splinkersets01/Makefile
> spstdthreads01/Makefile
> @@ -216,7 +217,6 @@ spintrcritical13/Makefile
> spintrcritical14/Makefile
> spintrcritical15/Makefile
> spintrcritical16/Makefile
> -spintrcritical17/Makefile
> spheapprot/Makefile
> spmkdir/Makefile
> spmountmgr01/Makefile
> diff --git a/testsuites/sptests/sp31/task1.c
> b/testsuites/sptests/sp31/task1.c
> index f4e526a..c3f0ae1 100644
> --- a/testsuites/sptests/sp31/task1.c
> +++ b/testsuites/sptests/sp31/task1.c
> @@ -40,14 +40,6 @@ static rtems_timer_service_routine Do_nothing(
> /* Do nothing */
> }
>
> -static Watchdog_Interval schedule_time( void )
> -{
> - const Watchdog_Control *watchdog =
> - &_Timer_server->Interval_watchdogs.System_watchdog;
> -
> - return watchdog->initial + watchdog->start_time;
> -}
> -
> rtems_task Task_1(
> rtems_task_argument argument
> )
> @@ -119,10 +111,6 @@ rtems_task Task_1(
> "Timer 1 scheduled for %" PRIdWatchdog_Interval " ticks since boot\n",
> info.start_time + info.initial
> );
> - printf(
> - "Timer Server scheduled for %" PRIdWatchdog_Interval " ticks since
> boot\n",
> - schedule_time()
> - );
>
> puts( "TA1 - rtems_task_wake_after - 1 second" );
> status = rtems_task_wake_after( 1 * rtems_clock_get_ticks_per_second()
> );
> @@ -139,11 +127,6 @@ rtems_task Task_1(
> "Timer 1 scheduled for %" PRIdWatchdog_Interval " ticks since boot\n",
> info.start_time + info.initial
> );
> - printf(
> - "Timer Server scheduled for %" PRIdWatchdog_Interval " ticks since
> boot\n",
> - schedule_time()
> - );
> - rtems_test_assert( (info.start_time + info.initial) == schedule_time()
> );
>
> puts( "TA1 - rtems_task_wake_after - 1 second" );
> status = rtems_task_wake_after( 1 * rtems_clock_get_ticks_per_second()
> );
> @@ -160,11 +143,6 @@ rtems_task Task_1(
> "Timer 1 scheduled for %" PRIdWatchdog_Interval " ticks since boot\n",
> info.start_time + info.initial
> );
> - printf(
> - "Timer Server scheduled for %" PRIdWatchdog_Interval " ticks since
> boot\n",
> - schedule_time()
> - );
> - rtems_test_assert( (info.start_time + info.initial) == schedule_time()
> );
>
> puts( "TA1 - rtems_timer_cancel - timer 1" );
> status = rtems_timer_cancel( tmid );
> diff --git a/testsuites/sptests/spintrcritical08/init.c
> b/testsuites/sptests/spintrcritical08/init.c
> index f375cd4..3610e65 100644
> --- a/testsuites/sptests/spintrcritical08/init.c
> +++ b/testsuites/sptests/spintrcritical08/init.c
> @@ -46,23 +46,21 @@ static rtems_timer_service_routine
> test_release_from_isr(
> void *arg
> )
> {
> - Watchdog_Header *header = &_Watchdog_Ticks_header;
> + Per_CPU_Control *cpu = _Per_CPU_Get();
> + Watchdog_Header *header = &cpu->Watchdog.Header[
> PER_CPU_WATCHDOG_RELATIVE ];
> + Watchdog_Control *watchdog = (Watchdog_Control *) header->first;
>
> - if ( !_Watchdog_Is_empty( header ) ) {
> - Watchdog_Control *watchdog = _Watchdog_First( header );
> + if (
> + watchdog != NULL
> + && watchdog->expire == cpu->Watchdog.ticks
> + && watchdog->routine == _Rate_monotonic_Timeout
> + ) {
> + _Watchdog_Per_CPU_remove_relative( watchdog );
>
> - if (
> - watchdog->delta_interval == 0
> - && watchdog->routine == _Rate_monotonic_Timeout
> - ) {
> - Watchdog_States state = _Watchdog_Remove_ticks( watchdog );
> + (*watchdog->routine)( watchdog );
>
> - rtems_test_assert( state == WATCHDOG_ACTIVE );
> - (*watchdog->routine)( watchdog->id, watchdog->user_data );
> -
> - if ( getState() == RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING ) {
> - case_hit = true;
> - }
> + if ( getState() == RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING ) {
> + case_hit = true;
> }
> }
> }
> diff --git a/testsuites/sptests/spintrcritical09/init.c
> b/testsuites/sptests/spintrcritical09/init.c
> index cc119e8..44eccc7 100644
> --- a/testsuites/sptests/spintrcritical09/init.c
> +++ b/testsuites/sptests/spintrcritical09/init.c
> @@ -15,6 +15,7 @@
> #include <intrcritical.h>
>
> #include <rtems/score/threadimpl.h>
> +#include <rtems/score/threadimpl.h>
> #include <rtems/score/watchdogimpl.h>
>
> const char rtems_test_name[] = "SPINTRCRITICAL 9";
> @@ -37,23 +38,21 @@ static rtems_timer_service_routine
> test_release_from_isr(
> void *arg
> )
> {
> - Watchdog_Header *header = &_Watchdog_Ticks_header;
> -
> - if ( !_Watchdog_Is_empty( header ) ) {
> - Watchdog_Control *watchdog = _Watchdog_First( header );
> + Per_CPU_Control *cpu_self = _Per_CPU_Get();
> + Watchdog_Header *header = &cpu_self->Watchdog.Header[
> PER_CPU_WATCHDOG_RELATIVE ];
> + Watchdog_Control *watchdog = (Watchdog_Control *) header->first;
>
> - if (
> - watchdog->delta_interval == 0
> - && watchdog->routine == _Thread_Timeout
> - ) {
> - Watchdog_States state = _Watchdog_Remove_ticks( watchdog );
> + if (
> + watchdog != NULL
> + && watchdog->expire == cpu_self->Watchdog.ticks
> + && watchdog->routine == _Thread_Timeout
> + ) {
> + _Watchdog_Per_CPU_remove( watchdog, cpu_self, header );
>
> - rtems_test_assert( state == WATCHDOG_ACTIVE );
> - (*watchdog->routine)( watchdog->id, watchdog->user_data );
> + (*watchdog->routine)( watchdog );
>
> - if ( is_interrupt_timeout() ) {
> - case_hit = true;
> - }
> + if ( is_interrupt_timeout() ) {
> + case_hit = true;
> }
> }
> }
> diff --git a/testsuites/sptests/spintrcritical10/init.c
> b/testsuites/sptests/spintrcritical10/init.c
> index e4a2a94..25be23a 100644
> --- a/testsuites/sptests/spintrcritical10/init.c
> +++ b/testsuites/sptests/spintrcritical10/init.c
> @@ -78,7 +78,7 @@ static void any_satisfy_before_timeout(rtems_id timer,
> void *arg)
> );
> rtems_test_assert(thread->Wait.return_code == RTEMS_SUCCESSFUL);
>
> - _Thread_Timeout(0, thread);
> + _Thread_Timeout(&thread->Timer.Watchdog);
>
> rtems_test_assert(
> *(rtems_event_set *) thread->Wait.return_argument == GREEN
> @@ -175,7 +175,7 @@ static void all_satisfy_before_timeout(rtems_id timer,
> void *arg)
> );
> rtems_test_assert(thread->Wait.return_code == RTEMS_SUCCESSFUL);
>
> - _Thread_Timeout(0, thread);
> + _Thread_Timeout(&thread->Timer.Watchdog);
>
> rtems_test_assert(
> *(rtems_event_set *) thread->Wait.return_argument == EVENTS
> @@ -251,7 +251,7 @@ static void timeout_before_satisfied(rtems_id timer,
> void *arg)
> );
> rtems_test_assert(thread->Wait.return_code == RTEMS_SUCCESSFUL);
>
> - _Thread_Timeout(0, thread);
> + _Thread_Timeout(&thread->Timer.Watchdog);
>
> rtems_test_assert(
> *(rtems_event_set *) thread->Wait.return_argument == DEADBEEF
> diff --git a/testsuites/sptests/spintrcritical16/init.c
> b/testsuites/sptests/spintrcritical16/init.c
> index a094b41..3657c06 100644
> --- a/testsuites/sptests/spintrcritical16/init.c
> +++ b/testsuites/sptests/spintrcritical16/init.c
> @@ -43,7 +43,7 @@ static rtems_timer_service_routine test_release_from_isr(
> }
>
> if ( Main_TCB->Wait.queue != NULL ) {
> - _Thread_Timeout( 0, Main_TCB );
> + _Thread_Timeout( &Main_TCB->Timer.Watchdog );
> }
> }
>
> diff --git a/testsuites/sptests/spintrcritical17/Makefile.am
> b/testsuites/sptests/spintrcritical17/Makefile.am
> deleted file mode 100644
> index 20b372c..0000000
> --- a/testsuites/sptests/spintrcritical17/Makefile.am
> +++ /dev/null
> @@ -1,25 +0,0 @@
> -
> -rtems_tests_PROGRAMS = spintrcritical17
> -spintrcritical17_SOURCES = init.c \
> - ../spintrcritical_support/intrcritical.c
> -spintrcritical17_SOURCES += ../spintrcritical_support/intrcritical.h
> -
> -dist_rtems_tests_DATA = spintrcritical17.scn
> -dist_rtems_tests_DATA += spintrcritical17.doc
> -
> -include $(RTEMS_ROOT)/make/custom/@RTEMS_BSP at .cfg
> -include $(top_srcdir)/../automake/compile.am
> -include $(top_srcdir)/../automake/leaf.am
> -
> -
> -AM_CPPFLAGS += -I$(top_srcdir)/../support/include
> -AM_CPPFLAGS += -I$(top_srcdir)/spintrcritical_support
> -
> -LINK_OBJS = $(spintrcritical17_OBJECTS)
> -LINK_LIBS = $(spintrcritical17_LDLIBS)
> -
> -spintrcritical17$(EXEEXT): $(spintrcritical17_OBJECTS)
> $(spintrcritical17_DEPENDENCIES)
> - @rm -f spintrcritical17$(EXEEXT)
> - $(make-exe)
> -
> -include $(top_srcdir)/../automake/local.am
> diff --git a/testsuites/sptests/spintrcritical17/init.c
> b/testsuites/sptests/spintrcritical17/init.c
> deleted file mode 100644
> index 238493e..0000000
> --- a/testsuites/sptests/spintrcritical17/init.c
> +++ /dev/null
> @@ -1,118 +0,0 @@
> -/*
> - * Copyright (c) 2009-2014 embedded brains GmbH.
> - *
> - * embedded brains GmbH
> - * Dornierstr. 4
> - * 82178 Puchheim
> - * Germany
> - * <rtems at embedded-brains.de>
> - *
> - * The license and distribution terms for this file may be
> - * found in the file LICENSE in this distribution or at
> - * http://www.rtems.org/license/LICENSE.
> - */
> -
> -#ifdef HAVE_CONFIG_H
> -#include "config.h"
> -#endif
> -
> -#include <tmacros.h>
> -#include <intrcritical.h>
> -
> -#include <rtems/rtems/timerimpl.h>
> -
> -const char rtems_test_name[] = "SPINTRCRITICAL 17";
> -
> -typedef struct {
> - rtems_id timer1;
> - rtems_id timer2;
> - bool done;
> -} test_context;
> -
> -static test_context ctx_instance;
> -
> -static void never(rtems_id timer_id, void *arg)
> -{
> - rtems_test_assert(0);
> -}
> -
> -static void fire(rtems_id timer_id, void *arg)
> -{
> - /* The arg is NULL */
> - test_context *ctx = &ctx_instance;
> - rtems_status_code sc;
> -
> - if (!ctx->done) {
> - ctx->done =
> - _Timer_server->Interval_watchdogs.system_watchdog_helper != NULL;
> -
> - if (ctx->done) {
> - sc = rtems_timer_server_fire_after(ctx->timer2, 100, never, NULL);
> - rtems_test_assert(sc == RTEMS_SUCCESSFUL);
> - }
> - }
> -}
> -
> -static bool test_body(void *arg)
> -{
> - test_context *ctx = arg;
> - rtems_status_code sc;
> -
> - sc = rtems_timer_reset(ctx->timer1);
> - rtems_test_assert(sc == RTEMS_SUCCESSFUL);
> -
> - return ctx->done;
> -}
> -
> -static void Init(rtems_task_argument ignored)
> -{
> - test_context *ctx = &ctx_instance;
> - rtems_status_code sc;
> -
> - TEST_BEGIN();
> -
> - sc = rtems_timer_create(
> - rtems_build_name('T', 'I', 'M', '1'),
> - &ctx->timer1
> - );
> - rtems_test_assert(sc == RTEMS_SUCCESSFUL);
> -
> - sc = rtems_timer_create(
> - rtems_build_name('T', 'I', 'M', '2'),
> - &ctx->timer2
> - );
> - rtems_test_assert(sc == RTEMS_SUCCESSFUL);
> -
> - sc = rtems_timer_initiate_server(
> - RTEMS_MINIMUM_PRIORITY,
> - RTEMS_MINIMUM_STACK_SIZE,
> - RTEMS_DEFAULT_ATTRIBUTES
> - );
> - rtems_test_assert(sc == RTEMS_SUCCESSFUL);
> -
> - sc = rtems_timer_server_fire_after(ctx->timer1, 1000, never, NULL);
> - rtems_test_assert(sc == RTEMS_SUCCESSFUL);
> -
> - interrupt_critical_section_test(test_body, ctx, fire);
> - rtems_test_assert(ctx->done);
> -
> - TEST_END();
> - rtems_test_exit(0);
> -}
> -
> -#define CONFIGURE_APPLICATION_NEEDS_CONSOLE_DRIVER
> -#define CONFIGURE_APPLICATION_NEEDS_CLOCK_DRIVER
> -
> -#define CONFIGURE_MICROSECONDS_PER_TICK 1000
> -
> -#define CONFIGURE_MAXIMUM_TASKS 2
> -#define CONFIGURE_MAXIMUM_TIMERS 3
> -#define CONFIGURE_MAXIMUM_USER_EXTENSIONS 1
> -
> -#define CONFIGURE_INITIAL_EXTENSIONS RTEMS_TEST_INITIAL_EXTENSION
> -
> -#define CONFIGURE_RTEMS_INIT_TASKS_TABLE
> -
> -#define CONFIGURE_INIT
> -
> -#include <rtems/confdefs.h>
> diff --git a/testsuites/sptests/spintrcritical17/spintrcritical17.doc
> b/testsuites/sptests/spintrcritical17/spintrcritical17.doc
> deleted file mode 100644
> index 809a966..0000000
> --- a/testsuites/sptests/spintrcritical17/spintrcritical17.doc
> +++ /dev/null
> @@ -1,18 +0,0 @@
> -# Copyright (c) 2009-2015 embedded brains GmbH.
> -#
> -# The license and distribution terms for this file may be
> -# found in the file LICENSE in this distribution or at
> -# http://www.rtems.org/license/LICENSE.
> -#
> -
> -This file describes the directives and concepts tested by this test set.
> -
> -test set name: spintrcritical17
> -
> -directives:
> -
> - _Timer_server_Update_system_watchdog
> -
> -concepts:
> -
> -+ Test critical sections which are only accessible through an interrupt.
> diff --git a/testsuites/sptests/spintrcritical17/spintrcritical17.scn
> b/testsuites/sptests/spintrcritical17/spintrcritical17.scn
> deleted file mode 100644
> index 14566df..0000000
> --- a/testsuites/sptests/spintrcritical17/spintrcritical17.scn
> +++ /dev/null
> @@ -1,2 +0,0 @@
> -*** TEST INTERRUPT CRITICAL SECTION 17 ***
> -*** END OF INTERRUPT CRITICAL SECTION 17 ***
> diff --git a/testsuites/sptests/spintrcritical20/init.c
> b/testsuites/sptests/spintrcritical20/init.c
> index 7e52211..85c1645 100644
> --- a/testsuites/sptests/spintrcritical20/init.c
> +++ b/testsuites/sptests/spintrcritical20/init.c
> @@ -91,7 +91,7 @@ static bool test_body(void *arg)
> ctx->thread_queue_was_null = true;
> }
>
> - _Thread_Timeout(0, ctx->semaphore_task_tcb);
> + _Thread_Timeout(&ctx->semaphore_task_tcb->Timer.Watchdog);
>
> switch (ctx->semaphore_task_tcb->Wait.return_code) {
> case CORE_SEMAPHORE_STATUS_SUCCESSFUL:
> diff --git a/testsuites/sptests/spsize/size.c
> b/testsuites/sptests/spsize/size.c
> index e9470e3..e19ca99 100644
> --- a/testsuites/sptests/spsize/size.c
> +++ b/testsuites/sptests/spsize/size.c
> @@ -391,8 +391,6 @@ uninitialized =
> /*userext.h*/ (sizeof _User_extensions_List) +
>
> /*watchdog.h*/ (sizeof _Watchdog_Ticks_since_boot) +
> - (sizeof _Watchdog_Ticks_header) +
> - (sizeof _Watchdog_Seconds_header) +
>
> /*wkspace.h*/ (sizeof _Workspace_Area);
>
> diff --git a/testsuites/sptests/sptimecounter01/init.c
> b/testsuites/sptests/sptimecounter01/init.c
> index 7b31064..d87ffec 100644
> --- a/testsuites/sptests/sptimecounter01/init.c
> +++ b/testsuites/sptests/sptimecounter01/init.c
> @@ -24,7 +24,6 @@
>
> #include <rtems/score/timecounterimpl.h>
> #include <rtems/score/todimpl.h>
> -#include <rtems/score/watchdogimpl.h>
> #include <rtems/timecounter.h>
> #include <rtems/bsd.h>
>
> @@ -57,8 +56,6 @@ void boot_card(const char *cmdline)
>
> rtems_test_begink();
>
> - _Watchdog_Handler_initialization();
> -
> assert(time(NULL) == TOD_SECONDS_1970_THROUGH_1988);
>
> rtems_bsd_bintime(&bt);
> diff --git a/testsuites/sptests/sptimerserver01/Makefile.am
> b/testsuites/sptests/sptimerserver01/Makefile.am
> new file mode 100644
> index 0000000..2e5048d
> --- /dev/null
> +++ b/testsuites/sptests/sptimerserver01/Makefile.am
> @@ -0,0 +1,19 @@
> +rtems_tests_PROGRAMS = sptimerserver01
> +sptimerserver01_SOURCES = init.c
> +
> +dist_rtems_tests_DATA = sptimerserver01.scn sptimerserver01.doc
> +
> +include $(RTEMS_ROOT)/make/custom/@RTEMS_BSP at .cfg
> +include $(top_srcdir)/../automake/compile.am
> +include $(top_srcdir)/../automake/leaf.am
> +
> +AM_CPPFLAGS += -I$(top_srcdir)/../support/include
> +
> +LINK_OBJS = $(sptimerserver01_OBJECTS)
> +LINK_LIBS = $(sptimerserver01_LDLIBS)
> +
> +sptimerserver01$(EXEEXT): $(sptimerserver01_OBJECTS)
> $(sptimerserver01_DEPENDENCIES)
> + @rm -f sptimerserver01$(EXEEXT)
> + $(make-exe)
> +
> +include $(top_srcdir)/../automake/local.am
> diff --git a/testsuites/sptests/sptimerserver01/init.c
> b/testsuites/sptests/sptimerserver01/init.c
> new file mode 100644
> index 0000000..88f1fb3
> --- /dev/null
> +++ b/testsuites/sptests/sptimerserver01/init.c
> @@ -0,0 +1,129 @@
> +/*
> + * Copyright (c) 2016 embedded brains GmbH. All rights reserved.
> + *
> + * embedded brains GmbH
> + * Dornierstr. 4
> + * 82178 Puchheim
> + * Germany
> + * <rtems at embedded-brains.de>
> + *
> + * The license and distribution terms for this file may be
> + * found in the file LICENSE in this distribution or at
> + * http://www.rtems.org/license/LICENSE.
> + */
> +
> +#ifdef HAVE_CONFIG_H
> + #include "config.h"
> +#endif
> +
> +#include "tmacros.h"
> +
> +const char rtems_test_name[] = "SPTIMERSERVER 1";
> +
> +#define TIMER_COUNT 2
> +
> +typedef struct {
> + rtems_id timer[TIMER_COUNT];
> + rtems_id master;
> +} test_context;
> +
> +static test_context ctx_instance;
> +
> +static const rtems_time_of_day start = {
> + .year = 2016,
> + .month = 3,
> + .day = 1,
> + .hour = 12,
> + .minute = 5,
> + .second = 17
> +};
> +
> +static void cancel(rtems_id id, void *arg)
> +{
> + test_context *ctx = arg;
> + rtems_status_code sc;
> +
> + sc = rtems_timer_cancel(ctx->timer[1]);
> + rtems_test_assert(sc == RTEMS_SUCCESSFUL);
> +
> + sc = rtems_event_transient_send(ctx->master);
> + rtems_test_assert(sc == RTEMS_SUCCESSFUL);
> +}
> +
> +static void never(rtems_id id, void *arg)
> +{
> + rtems_test_assert(0);
> +}
> +
> +static void test(void)
> +{
> + test_context *ctx = &ctx_instance;
> + rtems_status_code sc;
> + size_t i;
> + rtems_time_of_day later;
> +
> + ctx->master = rtems_task_self();
> +
> + sc = rtems_timer_initiate_server(
> + RTEMS_MINIMUM_PRIORITY,
> + RTEMS_MINIMUM_STACK_SIZE,
> + RTEMS_DEFAULT_ATTRIBUTES
> + );
> + rtems_test_assert(sc == RTEMS_SUCCESSFUL);
> +
> + for (i = 0; i < TIMER_COUNT; ++i) {
> + sc = rtems_timer_create(
> + rtems_build_name('T', 'M', 'R', '0' + i),
> + &ctx->timer[i]
> + );
> + rtems_test_assert(sc == RTEMS_SUCCESSFUL);
> + }
> +
> + sc = rtems_timer_server_fire_after(ctx->timer[0], 10, cancel, ctx);
> + rtems_test_assert(sc == RTEMS_SUCCESSFUL);
> +
> + sc = rtems_timer_server_fire_after(ctx->timer[1], 10, never, NULL);
> + rtems_test_assert(sc == RTEMS_SUCCESSFUL);
> +
> + sc = rtems_event_transient_receive(RTEMS_WAIT, RTEMS_NO_TIMEOUT);
> + rtems_test_assert(sc == RTEMS_SUCCESSFUL);
> +
> + sc = rtems_clock_set(&start);
> + rtems_test_assert(sc == RTEMS_SUCCESSFUL);
> +
> + later = start;
> + ++later.second;
> +
> + sc = rtems_timer_server_fire_when(ctx->timer[0], &later, cancel, ctx);
> + rtems_test_assert(sc == RTEMS_SUCCESSFUL);
> +
> + sc = rtems_timer_server_fire_when(ctx->timer[1], &later, never, NULL);
> + rtems_test_assert(sc == RTEMS_SUCCESSFUL);
> +
> + sc = rtems_event_transient_receive(RTEMS_WAIT, RTEMS_NO_TIMEOUT);
> + rtems_test_assert(sc == RTEMS_SUCCESSFUL);
> +}
> +
> +static void Init(rtems_task_argument arg)
> +{
> + TEST_BEGIN();
> +
> + test();
> +
> + TEST_END();
> + rtems_test_exit(0);
> +}
> +
> +#define CONFIGURE_APPLICATION_NEEDS_CLOCK_DRIVER
> +#define CONFIGURE_APPLICATION_NEEDS_CONSOLE_DRIVER
> +
> +#define CONFIGURE_MAXIMUM_TASKS 2
> +#define CONFIGURE_MAXIMUM_TIMERS TIMER_COUNT
> +
> +#define CONFIGURE_INITIAL_EXTENSIONS RTEMS_TEST_INITIAL_EXTENSION
> +
> +#define CONFIGURE_RTEMS_INIT_TASKS_TABLE
> +
> +#define CONFIGURE_INIT
> +
> +#include <rtems/confdefs.h>
> diff --git a/testsuites/sptests/sptimerserver01/sptimerserver01.doc
> b/testsuites/sptests/sptimerserver01/sptimerserver01.doc
> new file mode 100644
> index 0000000..c0dc4ef
> --- /dev/null
> +++ b/testsuites/sptests/sptimerserver01/sptimerserver01.doc
> @@ -0,0 +1,12 @@
> +This file describes the directives and concepts tested by this test set.
> +
> +test set name: sptimerserver01
> +
> +directives:
> +
> + - rtems_timer_cancel()
> +
> +concepts:
> +
> + - Ensure that pending timer server timers are cancelled via
> + rtems_timer_cancel().
> diff --git a/testsuites/sptests/sptimerserver01/sptimerserver01.scn
> b/testsuites/sptests/sptimerserver01/sptimerserver01.scn
> new file mode 100644
> index 0000000..315f030
> --- /dev/null
> +++ b/testsuites/sptests/sptimerserver01/sptimerserver01.scn
> @@ -0,0 +1,2 @@
> +*** BEGIN OF TEST SPTIMERSERVER 1 ***
> +*** END OF TEST SPTIMERSERVER 1 ***
> diff --git a/testsuites/sptests/spwatchdog/init.c
> b/testsuites/sptests/spwatchdog/init.c
> index 025295b..3b08fb5 100644
> --- a/testsuites/sptests/spwatchdog/init.c
> +++ b/testsuites/sptests/spwatchdog/init.c
> @@ -26,241 +26,192 @@
>
> const char rtems_test_name[] = "SPWATCHDOG";
>
> -static void test_watchdog_routine( Objects_Id id, void *arg )
> -{
> - (void) id;
> - (void) arg;
> -
> - rtems_test_assert( 0 );
> -}
> +typedef struct {
> + Watchdog_Control Base;
> + int counter;
> +} test_watchdog;
>
> -static void init_watchdogs(
> - Watchdog_Header *header,
> - Watchdog_Control watchdogs[4]
> -)
> +static void test_watchdog_routine( Watchdog_Control *base )
> {
> - Watchdog_Control *a = &watchdogs[0];
> - Watchdog_Control *b = &watchdogs[1];
> - Watchdog_Control *c = &watchdogs[2];
> - Watchdog_Control *d = &watchdogs[3];
> -
> - _Watchdog_Header_initialize( header );
> - rtems_test_assert( _Watchdog_Is_empty( header ) );
> - rtems_test_assert( _Chain_Is_empty( &header->Iterators ) );
> -
> - _Watchdog_Preinitialize( c );
> - c->initial = 6;
> - _Watchdog_Insert( header, c );
> - rtems_test_assert( c->delta_interval == 6 );
> -
> - rtems_test_assert( !_Watchdog_Is_empty( header ) );
> - rtems_test_assert( _Chain_Is_empty( &header->Iterators ) );
> -
> - _Watchdog_Preinitialize( a );
> - a->initial = 2;
> - _Watchdog_Insert( header, a );
> - rtems_test_assert( a->delta_interval == 2 );
> - rtems_test_assert( c->delta_interval == 4 );
> -
> - _Watchdog_Preinitialize( b );
> - b->initial = 4;
> - _Watchdog_Insert( header, b );
> - rtems_test_assert( a->delta_interval == 2 );
> - rtems_test_assert( b->delta_interval == 2 );
> - rtems_test_assert( c->delta_interval == 2 );
> -
> - _Watchdog_Preinitialize( d );
> -}
> + test_watchdog *watchdog = (test_watchdog *) base;
>
> -static void destroy_watchdogs(
> - Watchdog_Header *header
> -)
> -{
> - _ISR_lock_Destroy( &header->Lock );
> + ++watchdog->counter;
> }
>
> -static void add_iterator(
> - Watchdog_Header *header,
> - Watchdog_Iterator *i,
> - Watchdog_Control *w
> -)
> +static void test_watchdog_static_init( void )
> {
> - _Chain_Append_unprotected( &header->Iterators, &i->Node );
> - i->delta_interval = 2;
> - i->current = &w->Node;
> -}
> + static Watchdog_Control a = WATCHDOG_INITIALIZER(
> + test_watchdog_routine
> + );
> + Watchdog_Control b;
>
> -static void test_watchdog_insert_and_remove( void )
> -{
> - Watchdog_Header header;
> - Watchdog_Control watchdogs[4];
> - Watchdog_Control *a = &watchdogs[0];
> - Watchdog_Control *b = &watchdogs[1];
> - Watchdog_Control *c = &watchdogs[2];
> - Watchdog_Control *d = &watchdogs[3];
> - Watchdog_Iterator i;
> -
> - init_watchdogs( &header, watchdogs );
> - add_iterator( &header, &i, c );
> -
> - /* Remove next watchdog of iterator */
> - _Watchdog_Remove( &header, c );
> - rtems_test_assert( i.delta_interval == 4 );
> - rtems_test_assert( i.current == &b->Node );
> -
> - /* Remove watchdog before the current watchdog of iterator */
> - _Watchdog_Remove( &header, a );
> - rtems_test_assert( i.delta_interval == 6 );
> - rtems_test_assert( i.current == &b->Node );
> -
> - /* Remove current (= last) watchdog of iterator */
> - _Watchdog_Remove( &header, b );
> - rtems_test_assert( i.delta_interval == 6 );
> - rtems_test_assert( i.current == _Chain_Head( &header.Watchdogs ) );
> -
> - /* Insert first watchdog */
> - a->initial = 1;
> - _Watchdog_Insert( &header, a );
> - rtems_test_assert( i.delta_interval == 6 );
> - rtems_test_assert( i.current == _Chain_Head( &header.Watchdogs ) );
> -
> - destroy_watchdogs( &header );
> - init_watchdogs( &header, watchdogs );
> - add_iterator( &header, &i, b );
> -
> - /* Insert right before current watchdog of iterator */
> - d->initial = 3;
> - _Watchdog_Insert( &header, d );
> - rtems_test_assert( i.delta_interval == 2 );
> - rtems_test_assert( i.current == &d->Node );
> -
> - destroy_watchdogs( &header );
> - init_watchdogs( &header, watchdogs );
> - add_iterator( &header, &i, b );
> -
> - /* Insert right after current watchdog of iterator */
> - d->initial = 5;
> - _Watchdog_Insert( &header, d );
> - rtems_test_assert( i.delta_interval == 2 );
> - rtems_test_assert( i.current == &b->Node );
> -
> - destroy_watchdogs( &header );
> + memset( &b, 0, sizeof( b ) );
> + _Watchdog_Preinitialize( &b, _Per_CPU_Get_by_index( 0 ) );
> + _Watchdog_Initialize(
> + &b,
> + test_watchdog_routine
> + );
> +
> + rtems_test_assert( memcmp( &a, &b, sizeof( a ) ) == 0 );
> }
>
> -static void init_watchdogs_remove_second_and_insert_first(
> - Watchdog_Header *header,
> - Watchdog_Control watchdogs[3]
> -)
> +static bool test_watchdog_is_inactive( test_watchdog *watchdog )
> {
> - Watchdog_Control *a = &watchdogs[0];
> - Watchdog_Control *b = &watchdogs[1];
> - Watchdog_Control *c = &watchdogs[2];
> -
> - _Watchdog_Preinitialize( a );
> - _Watchdog_Preinitialize( b );
> - _Watchdog_Preinitialize( c );
> -
> - _Watchdog_Header_initialize( header );
> -
> - a->initial = 6;
> - _Watchdog_Insert( header, a );
> - rtems_test_assert( a->delta_interval == 6 );
> -
> - b->initial = 8;
> - _Watchdog_Insert( header, b );
> - rtems_test_assert( a->delta_interval == 6 );
> - rtems_test_assert( b->delta_interval == 2 );
> + return _Watchdog_Get_state( &watchdog->Base ) == WATCHDOG_INACTIVE;
> }
>
> -static void test_watchdog_remove_second_and_insert_first( void )
> +static void test_watchdog_init( test_watchdog *watchdog, int counter )
> {
> - Watchdog_Header header;
> - Watchdog_Control watchdogs[3];
> - Watchdog_Control *a = &watchdogs[0];
> - Watchdog_Control *b = &watchdogs[1];
> - Watchdog_Control *c = &watchdogs[2];
> - Watchdog_Iterator i;
> -
> - init_watchdogs_remove_second_and_insert_first( &header, watchdogs );
> - add_iterator( &header, &i, b );
> -
> - _Watchdog_Remove( &header, b );
> - rtems_test_assert( i.delta_interval == 8 );
> - rtems_test_assert( i.current == &a->Node );
> -
> - c->initial = 4;
> - _Watchdog_Insert( &header, c );
> - rtems_test_assert( a->delta_interval == 2 );
> - rtems_test_assert( c->delta_interval == 4 );
> - rtems_test_assert( i.delta_interval == 8 );
> - rtems_test_assert( i.current == &c->Node );
> -
> - destroy_watchdogs( &header );
> + _Watchdog_Preinitialize( &watchdog->Base, _Per_CPU_Get_snapshot() );
> + _Watchdog_Initialize( &watchdog->Base, test_watchdog_routine );
> + rtems_test_assert( test_watchdog_is_inactive( watchdog ) ) ;
> + watchdog->counter = counter;
> }
>
> -static void init_watchdogs_insert_with_iterator(
> - Watchdog_Header *header,
> - Watchdog_Control watchdogs[2]
> -)
> +static uint64_t test_watchdog_tick( Watchdog_Header *header, uint64_t now
> )
> {
> - Watchdog_Control *a = &watchdogs[0];
> - Watchdog_Control *b = &watchdogs[1];
> + ISR_LOCK_DEFINE( , lock, "Test" )
> + ISR_lock_Context lock_context;
>
> - _Watchdog_Preinitialize( a );
> - _Watchdog_Preinitialize( b );
> + _ISR_lock_ISR_disable_and_acquire( &lock, &lock_context );
> + ++now;
> + _Watchdog_Tickle( header, now, &lock, &lock_context );
> + _ISR_lock_Destroy( &lock );
>
> - _Watchdog_Header_initialize( header );
> -
> - a->initial = 6;
> - _Watchdog_Insert( header, a );
> - rtems_test_assert( a->delta_interval == 6 );
> + return now;
> }
>
> -static void test_watchdog_insert_with_iterator( void )
> +static void test_watchdog_operations( void )
> {
> Watchdog_Header header;
> - Watchdog_Control watchdogs[2];
> - Watchdog_Control *a = &watchdogs[0];
> - Watchdog_Control *b = &watchdogs[1];
> - Watchdog_Iterator i;
> -
> - init_watchdogs_insert_with_iterator( &header, watchdogs );
> - add_iterator( &header, &i, a );
> -
> - b->initial = 4;
> - _Watchdog_Insert( &header, b );
> - rtems_test_assert( a->delta_interval == 2 );
> - rtems_test_assert( b->delta_interval == 4 );
> - rtems_test_assert( i.delta_interval == 2 );
> - rtems_test_assert( i.current == &b->Node );
> -
> - destroy_watchdogs( &header );
> -}
> -
> -static void test_watchdog_static_init( void )
> -{
> - #if defined(RTEMS_USE_16_BIT_OBJECT)
> - #define JUNK_ID 0x1234
> - #else
> - #define JUNK_ID 0x12345678
> - #endif
> -
> - static Watchdog_Control a = WATCHDOG_INITIALIZER(
> - test_watchdog_routine,
> - JUNK_ID,
> - (void *) 0xdeadbeef
> - );
> - Watchdog_Control b;
> -
> - memset( &b, 0, sizeof( b ) );
> - _Watchdog_Initialize(
> - &b,
> - test_watchdog_routine,
> - JUNK_ID,
> - (void *) 0xdeadbeef
> - );
> -
> - rtems_test_assert( memcmp( &a, &b, sizeof( a ) ) == 0 );
> + uint64_t now;
> + test_watchdog a;
> + test_watchdog b;
> + test_watchdog c;
> +
> + _Watchdog_Header_initialize( &header );
> + rtems_test_assert( _RBTree_Is_empty( &header.Watchdogs ) );
> + rtems_test_assert( header.first == NULL );
> +
> + test_watchdog_init( &a, 10 );
> + test_watchdog_init( &b, 20 );
> + test_watchdog_init( &c, 30 );
> +
> + now = 0;
> + now = test_watchdog_tick( &header, now );
> +
> + _Watchdog_Insert( &header, &a.Base, now + 1 );
> + rtems_test_assert( header.first == &a.Base.Node.RBTree );
> + rtems_test_assert( !test_watchdog_is_inactive( &a ) ) ;
> + rtems_test_assert( a.Base.expire == 2 );
> + rtems_test_assert( a.counter == 10 );
> +
> + _Watchdog_Remove( &header, &a.Base );
> + rtems_test_assert( header.first == NULL );
> + rtems_test_assert( test_watchdog_is_inactive( &a ) ) ;
> + rtems_test_assert( a.Base.expire == 2 );
> + rtems_test_assert( a.counter == 10 );
> +
> + _Watchdog_Remove( &header, &a.Base );
> + rtems_test_assert( header.first == NULL );
> + rtems_test_assert( test_watchdog_is_inactive( &a ) ) ;
> + rtems_test_assert( a.Base.expire == 2 );
> + rtems_test_assert( a.counter == 10 );
> +
> + _Watchdog_Insert( &header, &a.Base, now + 1 );
> + rtems_test_assert( header.first == &a.Base.Node.RBTree );
> + rtems_test_assert( !test_watchdog_is_inactive( &a ) ) ;
> + rtems_test_assert( a.Base.expire == 2 );
> + rtems_test_assert( a.counter == 10 );
> +
> + _Watchdog_Insert( &header, &b.Base, now + 1 );
> + rtems_test_assert( header.first == &a.Base.Node.RBTree );
> + rtems_test_assert( !test_watchdog_is_inactive( &b ) ) ;
> + rtems_test_assert( b.Base.expire == 2 );
> + rtems_test_assert( b.counter == 20 );
> +
> + _Watchdog_Insert( &header, &c.Base, now + 2 );
> + rtems_test_assert( header.first == &a.Base.Node.RBTree );
> + rtems_test_assert( !test_watchdog_is_inactive( &c ) ) ;
> + rtems_test_assert( c.Base.expire == 3 );
> + rtems_test_assert( c.counter == 30 );
> +
> + _Watchdog_Remove( &header, &a.Base );
> + rtems_test_assert( header.first == &b.Base.Node.RBTree );
> + rtems_test_assert( test_watchdog_is_inactive( &a ) ) ;
> + rtems_test_assert( a.Base.expire == 2 );
> + rtems_test_assert( a.counter == 10 );
> +
> + _Watchdog_Remove( &header, &b.Base );
> + rtems_test_assert( header.first == &c.Base.Node.RBTree );
> + rtems_test_assert( test_watchdog_is_inactive( &b ) ) ;
> + rtems_test_assert( b.Base.expire == 2 );
> + rtems_test_assert( b.counter == 20 );
> +
> + _Watchdog_Remove( &header, &c.Base );
> + rtems_test_assert( header.first == NULL );
> + rtems_test_assert( test_watchdog_is_inactive( &c ) ) ;
> + rtems_test_assert( c.Base.expire == 3 );
> + rtems_test_assert( c.counter == 30 );
> +
> + _Watchdog_Insert( &header, &a.Base, now + 2 );
> + rtems_test_assert( header.first == &a.Base.Node.RBTree );
> + rtems_test_assert( !test_watchdog_is_inactive( &a ) ) ;
> + rtems_test_assert( a.Base.expire == 3 );
> + rtems_test_assert( a.counter == 10 );
> +
> + _Watchdog_Insert( &header, &b.Base, now + 2 );
> + rtems_test_assert( header.first == &a.Base.Node.RBTree );
> + rtems_test_assert( !test_watchdog_is_inactive( &b ) ) ;
> + rtems_test_assert( b.Base.expire == 3 );
> + rtems_test_assert( b.counter == 20 );
> +
> + _Watchdog_Insert( &header, &c.Base, now + 3 );
> + rtems_test_assert( header.first == &a.Base.Node.RBTree );
> + rtems_test_assert( !test_watchdog_is_inactive( &c ) ) ;
> + rtems_test_assert( c.Base.expire == 4 );
> + rtems_test_assert( c.counter == 30 );
> +
> + now = test_watchdog_tick( &header, now );
> + rtems_test_assert( !_RBTree_Is_empty( &header.Watchdogs ) );
> + rtems_test_assert( header.first == &a.Base.Node.RBTree );
> + rtems_test_assert( !test_watchdog_is_inactive( &a ) ) ;
> + rtems_test_assert( a.Base.expire == 3 );
> + rtems_test_assert( a.counter == 10 );
> + rtems_test_assert( !test_watchdog_is_inactive( &b ) ) ;
> + rtems_test_assert( b.Base.expire == 3 );
> + rtems_test_assert( b.counter == 20 );
> + rtems_test_assert( !test_watchdog_is_inactive( &c ) ) ;
> + rtems_test_assert( c.Base.expire == 4 );
> + rtems_test_assert( c.counter == 30 );
> +
> + now = test_watchdog_tick( &header, now );
> + rtems_test_assert( !_RBTree_Is_empty( &header.Watchdogs ) );
> + rtems_test_assert( header.first == &c.Base.Node.RBTree );
> + rtems_test_assert( test_watchdog_is_inactive( &a ) ) ;
> + rtems_test_assert( a.Base.expire == 3 );
> + rtems_test_assert( a.counter == 11 );
> + rtems_test_assert( test_watchdog_is_inactive( &b ) ) ;
> + rtems_test_assert( b.Base.expire == 3 );
> + rtems_test_assert( b.counter == 21 );
> + rtems_test_assert( !test_watchdog_is_inactive( &c ) ) ;
> + rtems_test_assert( c.Base.expire == 4 );
> + rtems_test_assert( c.counter == 30 );
> +
> + now = test_watchdog_tick( &header, now );
> + rtems_test_assert( _RBTree_Is_empty( &header.Watchdogs ) );
> + rtems_test_assert( header.first == NULL );
> + rtems_test_assert( test_watchdog_is_inactive( &a ) ) ;
> + rtems_test_assert( a.Base.expire == 3 );
> + rtems_test_assert( a.counter == 11 );
> + rtems_test_assert( test_watchdog_is_inactive( &b ) ) ;
> + rtems_test_assert( b.Base.expire == 3 );
> + rtems_test_assert( b.counter == 21 );
> + rtems_test_assert( test_watchdog_is_inactive( &c ) ) ;
> + rtems_test_assert( c.Base.expire == 4 );
> + rtems_test_assert( c.counter == 31 );
> +
> + _Watchdog_Header_destroy( &header );
> }
>
> rtems_task Init(
> @@ -272,10 +223,8 @@ rtems_task Init(
>
> TEST_BEGIN();
>
> + test_watchdog_operations();
> test_watchdog_static_init();
> - test_watchdog_insert_and_remove();
> - test_watchdog_remove_second_and_insert_first();
> - test_watchdog_insert_with_iterator();
>
> build_time( &time, 12, 31, 1988, 9, 0, 0, 0 );
>
> diff --git a/testsuites/tmtests/tmtimer01/tmtimer01.scn
> b/testsuites/tmtests/tmtimer01/tmtimer01.scn
> index ea882d4..db3ca01 100644
> --- a/testsuites/tmtests/tmtimer01/tmtimer01.scn
> +++ b/testsuites/tmtests/tmtimer01/tmtimer01.scn
> @@ -1,137 +1,137 @@
> <TMTimer01 timerCount="65504">
> <Sample>
> - <ActiveTimers>0</ActiveTimers><First unit="ns">6397</First><Middle
> unit="ns">3290</Middle><Last unit="ns">1527</Last>
> + <ActiveTimers>0</ActiveTimers><First unit="ns">8812</First><Middle
> unit="ns">1412</Middle><Last unit="ns">917</Last>
> </Sample>
> <Sample>
> - <ActiveTimers>2</ActiveTimers><First unit="ns">1986</First><Middle
> unit="ns">1550</Middle><Last unit="ns">1314</Last>
> + <ActiveTimers>2</ActiveTimers><First unit="ns">1602</First><Middle
> unit="ns">1010</Middle><Last unit="ns">1367</Last>
> </Sample>
> <Sample>
> - <ActiveTimers>4</ActiveTimers><First unit="ns">1551</First><Middle
> unit="ns">2134</Middle><Last unit="ns">3072</Last>
> + <ActiveTimers>4</ActiveTimers><First unit="ns">1524</First><Middle
> unit="ns">1089</Middle><Last unit="ns">1086</Last>
> </Sample>
> <Sample>
> - <ActiveTimers>7</ActiveTimers><First unit="ns">2545</First><Middle
> unit="ns">3511</Middle><Last unit="ns">3404</Last>
> + <ActiveTimers>7</ActiveTimers><First unit="ns">1791</First><Middle
> unit="ns">1121</Middle><Last unit="ns">1838</Last>
> </Sample>
> <Sample>
> - <ActiveTimers>10</ActiveTimers><First unit="ns">1595</First><Middle
> unit="ns">2363</Middle><Last unit="ns">4287</Last>
> + <ActiveTimers>10</ActiveTimers><First unit="ns">1488</First><Middle
> unit="ns">1016</Middle><Last unit="ns">2134</Last>
> </Sample>
> <Sample>
> - <ActiveTimers>14</ActiveTimers><First unit="ns">1473</First><Middle
> unit="ns">2740</Middle><Last unit="ns">6069</Last>
> + <ActiveTimers>14</ActiveTimers><First unit="ns">1527</First><Middle
> unit="ns">1698</Middle><Last unit="ns">3186</Last>
> </Sample>
> <Sample>
> - <ActiveTimers>19</ActiveTimers><First unit="ns">1566</First><Middle
> unit="ns">3195</Middle><Last unit="ns">5993</Last>
> + <ActiveTimers>19</ActiveTimers><First unit="ns">2078</First><Middle
> unit="ns">1665</Middle><Last unit="ns">3397</Last>
> </Sample>
> <Sample>
> - <ActiveTimers>25</ActiveTimers><First unit="ns">1251</First><Middle
> unit="ns">2718</Middle><Last unit="ns">7307</Last>
> + <ActiveTimers>25</ActiveTimers><First unit="ns">1519</First><Middle
> unit="ns">2368</Middle><Last unit="ns">4464</Last>
> </Sample>
> <Sample>
> - <ActiveTimers>32</ActiveTimers><First unit="ns">2302</First><Middle
> unit="ns">5690</Middle><Last unit="ns">10269</Last>
> + <ActiveTimers>32</ActiveTimers><First unit="ns">1243</First><Middle
> unit="ns">2623</Middle><Last unit="ns">3549</Last>
> </Sample>
> <Sample>
> - <ActiveTimers>41</ActiveTimers><First unit="ns">1522</First><Middle
> unit="ns">8221</Middle><Last unit="ns">13424</Last>
> + <ActiveTimers>41</ActiveTimers><First unit="ns">2368</First><Middle
> unit="ns">2578</Middle><Last unit="ns">4105</Last>
> </Sample>
> <Sample>
> - <ActiveTimers>52</ActiveTimers><First unit="ns">1799</First><Middle
> unit="ns">8455</Middle><Last unit="ns">14820</Last>
> + <ActiveTimers>52</ActiveTimers><First unit="ns">2322</First><Middle
> unit="ns">2563</Middle><Last unit="ns">4126</Last>
> </Sample>
> <Sample>
> - <ActiveTimers>66</ActiveTimers><First unit="ns">1062</First><Middle
> unit="ns">12480</Middle><Last unit="ns">16590</Last>
> + <ActiveTimers>66</ActiveTimers><First unit="ns">2499</First><Middle
> unit="ns">1855</Middle><Last unit="ns">4919</Last>
> </Sample>
> <Sample>
> - <ActiveTimers>83</ActiveTimers><First unit="ns">1384</First><Middle
> unit="ns">11710</Middle><Last unit="ns">21854</Last>
> + <ActiveTimers>83</ActiveTimers><First unit="ns">1689</First><Middle
> unit="ns">3128</Middle><Last unit="ns">5894</Last>
> </Sample>
> <Sample>
> - <ActiveTimers>104</ActiveTimers><First unit="ns">1666</First><Middle
> unit="ns">15200</Middle><Last unit="ns">30951</Last>
> + <ActiveTimers>104</ActiveTimers><First unit="ns">2301</First><Middle
> unit="ns">2647</Middle><Last unit="ns">4595</Last>
> </Sample>
> <Sample>
> - <ActiveTimers>130</ActiveTimers><First unit="ns">1345</First><Middle
> unit="ns">17154</Middle><Last unit="ns">37942</Last>
> + <ActiveTimers>130</ActiveTimers><First unit="ns">2880</First><Middle
> unit="ns">3183</Middle><Last unit="ns">6222</Last>
> </Sample>
> <Sample>
> - <ActiveTimers>162</ActiveTimers><First unit="ns">1369</First><Middle
> unit="ns">22381</Middle><Last unit="ns">46929</Last>
> + <ActiveTimers>162</ActiveTimers><First unit="ns">2597</First><Middle
> unit="ns">2376</Middle><Last unit="ns">7118</Last>
> </Sample>
> <Sample>
> - <ActiveTimers>201</ActiveTimers><First unit="ns">2271</First><Middle
> unit="ns">35625</Middle><Last unit="ns">59972</Last>
> + <ActiveTimers>201</ActiveTimers><First unit="ns">3519</First><Middle
> unit="ns">3466</Middle><Last unit="ns">6673</Last>
> </Sample>
> <Sample>
> - <ActiveTimers>249</ActiveTimers><First unit="ns">1279</First><Middle
> unit="ns">37271</Middle><Last unit="ns">69662</Last>
> + <ActiveTimers>249</ActiveTimers><First unit="ns">2829</First><Middle
> unit="ns">3177</Middle><Last unit="ns">7784</Last>
> </Sample>
> <Sample>
> - <ActiveTimers>308</ActiveTimers><First unit="ns">864</First><Middle
> unit="ns">44580</Middle><Last unit="ns">87633</Last>
> + <ActiveTimers>308</ActiveTimers><First unit="ns">2614</First><Middle
> unit="ns">3396</Middle><Last unit="ns">7338</Last>
> </Sample>
> <Sample>
> - <ActiveTimers>381</ActiveTimers><First unit="ns">1078</First><Middle
> unit="ns">53821</Middle><Last unit="ns">106376</Last>
> + <ActiveTimers>381</ActiveTimers><First unit="ns">3454</First><Middle
> unit="ns">4888</Middle><Last unit="ns">9114</Last>
> </Sample>
> <Sample>
> - <ActiveTimers>470</ActiveTimers><First unit="ns">913</First><Middle
> unit="ns">67021</Middle><Last unit="ns">133201</Last>
> + <ActiveTimers>470</ActiveTimers><First unit="ns">3397</First><Middle
> unit="ns">2443</Middle><Last unit="ns">7689</Last>
> </Sample>
> <Sample>
> - <ActiveTimers>580</ActiveTimers><First unit="ns">1870</First><Middle
> unit="ns">79863</Middle><Last unit="ns">169394</Last>
> + <ActiveTimers>580</ActiveTimers><First unit="ns">2233</First><Middle
> unit="ns">4410</Middle><Last unit="ns">9355</Last>
> </Sample>
> <Sample>
> - <ActiveTimers>715</ActiveTimers><First unit="ns">1732</First><Middle
> unit="ns">99965</Middle><Last unit="ns">208901</Last>
> + <ActiveTimers>715</ActiveTimers><First unit="ns">3787</First><Middle
> unit="ns">5891</Middle><Last unit="ns">6833</Last>
> </Sample>
> <Sample>
> - <ActiveTimers>881</ActiveTimers><First unit="ns">1503</First><Middle
> unit="ns">138820</Middle><Last unit="ns">259314</Last>
> + <ActiveTimers>881</ActiveTimers><First unit="ns">3839</First><Middle
> unit="ns">5089</Middle><Last unit="ns">9232</Last>
> </Sample>
> <Sample>
> - <ActiveTimers>1085</ActiveTimers><First unit="ns">1096</First><Middle
> unit="ns">166404</Middle><Last unit="ns">337461</Last>
> + <ActiveTimers>1085</ActiveTimers><First unit="ns">2838</First><Middle
> unit="ns">2739</Middle><Last unit="ns">11575</Last>
> </Sample>
> <Sample>
> - <ActiveTimers>1336</ActiveTimers><First unit="ns">1383</First><Middle
> unit="ns">209434</Middle><Last unit="ns">445806</Last>
> + <ActiveTimers>1336</ActiveTimers><First unit="ns">3256</First><Middle
> unit="ns">5011</Middle><Last unit="ns">9684</Last>
> </Sample>
> <Sample>
> - <ActiveTimers>1645</ActiveTimers><First unit="ns">1787</First><Middle
> unit="ns">253904</Middle><Last unit="ns">533644</Last>
> + <ActiveTimers>1645</ActiveTimers><First unit="ns">2293</First><Middle
> unit="ns">5262</Middle><Last unit="ns">10183</Last>
> </Sample>
> <Sample>
> - <ActiveTimers>2025</ActiveTimers><First unit="ns">2082</First><Middle
> unit="ns">327384</Middle><Last unit="ns">657141</Last>
> + <ActiveTimers>2025</ActiveTimers><First unit="ns">4436</First><Middle
> unit="ns">5934</Middle><Last unit="ns">8804</Last>
> </Sample>
> <Sample>
> - <ActiveTimers>2492</ActiveTimers><First unit="ns">1843</First><Middle
> unit="ns">417457</Middle><Last unit="ns">814380</Last>
> + <ActiveTimers>2492</ActiveTimers><First unit="ns">4506</First><Middle
> unit="ns">7284</Middle><Last unit="ns">10389</Last>
> </Sample>
> <Sample>
> - <ActiveTimers>3067</ActiveTimers><First unit="ns">1980</First><Middle
> unit="ns">493511</Middle><Last unit="ns">977427</Last>
> + <ActiveTimers>3067</ActiveTimers><First unit="ns">3832</First><Middle
> unit="ns">4990</Middle><Last unit="ns">9536</Last>
> </Sample>
> <Sample>
> - <ActiveTimers>3774</ActiveTimers><First unit="ns">2695</First><Middle
> unit="ns">622065</Middle><Last unit="ns">1237577</Last>
> + <ActiveTimers>3774</ActiveTimers><First unit="ns">5088</First><Middle
> unit="ns">4888</Middle><Last unit="ns">9633</Last>
> </Sample>
> <Sample>
> - <ActiveTimers>4644</ActiveTimers><First unit="ns">1463</First><Middle
> unit="ns">827565</Middle><Last unit="ns">1565553</Last>
> + <ActiveTimers>4644</ActiveTimers><First unit="ns">5590</First><Middle
> unit="ns">5749</Middle><Last unit="ns">8975</Last>
> </Sample>
> <Sample>
> - <ActiveTimers>5714</ActiveTimers><First unit="ns">1866</First><Middle
> unit="ns">1053458</Middle><Last unit="ns">1914932</Last>
> + <ActiveTimers>5714</ActiveTimers><First unit="ns">4854</First><Middle
> unit="ns">6813</Middle><Last unit="ns">11603</Last>
> </Sample>
> <Sample>
> - <ActiveTimers>7030</ActiveTimers><First unit="ns">3481</First><Middle
> unit="ns">1266198</Middle><Last unit="ns">2450199</Last>
> + <ActiveTimers>7030</ActiveTimers><First unit="ns">6139</First><Middle
> unit="ns">6132</Middle><Last unit="ns">12630</Last>
> </Sample>
> <Sample>
> - <ActiveTimers>8649</ActiveTimers><First unit="ns">2773</First><Middle
> unit="ns">1558351</Middle><Last unit="ns">2967472</Last>
> + <ActiveTimers>8649</ActiveTimers><First unit="ns">6877</First><Middle
> unit="ns">3852</Middle><Last unit="ns">10973</Last>
> </Sample>
> <Sample>
> - <ActiveTimers>10640</ActiveTimers><First
> unit="ns">2086</First><Middle unit="ns">2003884</Middle><Last
> unit="ns">3766161</Last>
> + <ActiveTimers>10640</ActiveTimers><First
> unit="ns">6532</First><Middle unit="ns">6097</Middle><Last
> unit="ns">11725</Last>
> </Sample>
> <Sample>
> - <ActiveTimers>13089</ActiveTimers><First
> unit="ns">3911</First><Middle unit="ns">2501427</Middle><Last
> unit="ns">4619553</Last>
> + <ActiveTimers>13089</ActiveTimers><First
> unit="ns">5284</First><Middle unit="ns">5392</Middle><Last
> unit="ns">13246</Last>
> </Sample>
> <Sample>
> - <ActiveTimers>16101</ActiveTimers><First
> unit="ns">3276</First><Middle unit="ns">3189159</Middle><Last
> unit="ns">5886373</Last>
> + <ActiveTimers>16101</ActiveTimers><First
> unit="ns">7077</First><Middle unit="ns">7572</Middle><Last
> unit="ns">14820</Last>
> </Sample>
> <Sample>
> - <ActiveTimers>19806</ActiveTimers><First
> unit="ns">3801</First><Middle unit="ns">4005049</Middle><Last
> unit="ns">7394938</Last>
> + <ActiveTimers>19806</ActiveTimers><First
> unit="ns">7132</First><Middle unit="ns">8335</Middle><Last
> unit="ns">11668</Last>
> </Sample>
> <Sample>
> - <ActiveTimers>24363</ActiveTimers><First
> unit="ns">3088</First><Middle unit="ns">4977788</Middle><Last
> unit="ns">9138839</Last>
> + <ActiveTimers>24363</ActiveTimers><First
> unit="ns">8676</First><Middle unit="ns">7919</Middle><Last
> unit="ns">13937</Last>
> </Sample>
> <Sample>
> - <ActiveTimers>29968</ActiveTimers><First
> unit="ns">4089</First><Middle unit="ns">6133462</Middle><Last
> unit="ns">11361012</Last>
> + <ActiveTimers>29968</ActiveTimers><First
> unit="ns">5970</First><Middle unit="ns">10978</Middle><Last
> unit="ns">16035</Last>
> </Sample>
> <Sample>
> - <ActiveTimers>36862</ActiveTimers><First
> unit="ns">2059</First><Middle unit="ns">7870138</Middle><Last
> unit="ns">14319206</Last>
> + <ActiveTimers>36862</ActiveTimers><First
> unit="ns">8804</First><Middle unit="ns">8767</Middle><Last
> unit="ns">13089</Last>
> </Sample>
> <Sample>
> - <ActiveTimers>45342</ActiveTimers><First
> unit="ns">2224</First><Middle unit="ns">9917100</Middle><Last
> unit="ns">17754441</Last>
> + <ActiveTimers>45342</ActiveTimers><First
> unit="ns">8608</First><Middle unit="ns">10305</Middle><Last
> unit="ns">15709</Last>
> </Sample>
> <Sample>
> - <ActiveTimers>55772</ActiveTimers><First
> unit="ns">1979</First><Middle unit="ns">11815557</Middle><Last
> unit="ns">21907509</Last>
> + <ActiveTimers>55772</ActiveTimers><First
> unit="ns">8949</First><Middle unit="ns">10031</Middle><Last
> unit="ns">16262</Last>
> </Sample>
> <Sample>
> - <ActiveTimers>65503</ActiveTimers><First
> unit="ns">2404</First><Middle unit="ns">13694591</Middle><Last
> unit="ns">26215885</Last>
> + <ActiveTimers>65503</ActiveTimers><First
> unit="ns">9199</First><Middle unit="ns">10309</Middle><Last
> unit="ns">19090</Last>
> </Sample>
> </TMTimer01>
> --
> 1.8.4.5
>
> _______________________________________________
> devel mailing list
> devel at rtems.org
> http://lists.rtems.org/mailman/listinfo/devel
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.rtems.org/pipermail/devel/attachments/20160303/ffaee83f/attachment-0002.html>
More information about the devel
mailing list