diff options
30 files changed, 573 insertions, 159 deletions
diff --git a/cpukit/ChangeLog b/cpukit/ChangeLog index 5d6c5eed12..daede54b8d 100644 --- a/cpukit/ChangeLog +++ b/cpukit/ChangeLog @@ -1,5 +1,29 @@ 2008-12-08 Joel Sherrill <joel.sherrill@oarcorp.com> + * libcsupport/src/__times.c, libmisc/cpuuse/cpuusagereport.c, + libmisc/cpuuse/cpuusagereset.c, posix/src/clockgettime.c, + posix/src/pthread.c, posix/src/timersettime.c, + rtems/include/rtems/rtems/ratemon.h, + rtems/src/clockgetsecondssinceepoch.c, rtems/src/clockgetuptime.c, + rtems/src/ratemongetstatus.c, rtems/src/ratemonperiod.c, + rtems/src/ratemonreportstatistics.c, rtems/src/taskwakewhen.c, + rtems/src/timerfirewhen.c, rtems/src/timerserver.c, + rtems/src/timerserverfirewhen.c, score/Makefile.am, + score/preinstall.am, score/include/rtems/score/thread.h, + score/include/rtems/score/tod.h, score/src/coretod.c, + score/src/coretodget.c, score/src/coretodgetuptime.c, + score/src/coretodset.c, score/src/coretodtickle.c, + score/src/threaddispatch.c, score/src/threadinitialize.c: Add + SuperCore handler Timestamp to provide an opaque class for the + representation and manipulation of uptime, time of day, and the + difference between two timestamps. By using SuperCore Timestamp, it + is clear which methods and APIs really have to be struct timespec and + which can be in an optimized native format. + * score/include/rtems/score/timestamp.h, + score/src/coretodgetuptimetimespec.c: New files. + +2008-12-08 Joel Sherrill <joel.sherrill@oarcorp.com> + * libfs/src/nfsclient/src/nfs.c: Use rtems_clock_get_seconds_since_epoch() from public API. diff --git a/cpukit/libcsupport/src/__times.c b/cpukit/libcsupport/src/__times.c index 086144dd77..8ddad3ad9f 100644 --- a/cpukit/libcsupport/src/__times.c +++ b/cpukit/libcsupport/src/__times.c @@ -1,7 +1,7 @@ /* * times() - POSIX 1003.1b 4.5.2 - Get Process Times * - * COPYRIGHT (c) 1989-1999. + * COPYRIGHT (c) 1989-2008. * On-Line Applications Research Corporation (OAR). * * The license and distribution terms for this file may be @@ -23,7 +23,7 @@ #include <errno.h> #include <assert.h> #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS - #include <rtems/score/timespec.h> + #include <rtems/score/timestamp.h> #endif clock_t _times( @@ -53,16 +53,17 @@ clock_t _times( #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS { - struct timespec per_tick; - uint32_t ticks; - uint32_t fractional_ticks; + Timestamp_Control per_tick; + uint32_t ticks; + uint32_t fractional_ticks; - per_tick.tv_sec = - _TOD_Microseconds_per_tick / TOD_MILLISECONDS_PER_SECOND; - per_tick.tv_nsec = - (_TOD_Microseconds_per_tick % TOD_MILLISECONDS_PER_SECOND) / 1000; + _Timestamp_Set( + &per_tick, + _TOD_Microseconds_per_tick / TOD_MILLISECONDS_PER_SECOND, + (_TOD_Microseconds_per_tick % TOD_MILLISECONDS_PER_SECOND) / 1000 + ); - _Timespec_Divide( + _Timestamp_Divide( &_Thread_Executing->cpu_time_used, &per_tick, &ticks, diff --git a/cpukit/libmisc/cpuuse/cpuusagereport.c b/cpukit/libmisc/cpuuse/cpuusagereport.c index 144be50645..b0144948e4 100644 --- a/cpukit/libmisc/cpuuse/cpuusagereport.c +++ b/cpukit/libmisc/cpuuse/cpuusagereport.c @@ -28,11 +28,11 @@ #include <rtems/bspIo.h> #if defined(RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS) - #include <rtems/score/timespec.h> + #include <rtems/score/timestamp.h> #endif #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS - extern struct timespec CPU_usage_Uptime_at_last_reset; + extern Timestamp_Control CPU_usage_Uptime_at_last_reset; #else extern uint32_t CPU_usage_Ticks_at_last_reset; #endif @@ -54,7 +54,7 @@ void rtems_cpu_usage_report_with_plugin( char name[13]; uint32_t ival, fval; #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS - struct timespec uptime, total, ran; + Timestamp_Control uptime, total, ran; #else uint32_t total_units = 0; #endif @@ -69,7 +69,7 @@ void rtems_cpu_usage_report_with_plugin( */ #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS _TOD_Get_uptime( &uptime ); - _Timespec_Subtract( &CPU_usage_Uptime_at_last_reset, &uptime, &total ); + _Timestamp_Subtract( &CPU_usage_Uptime_at_last_reset, &uptime, &total ); #else for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) { if ( !_Objects_Information_table[ api_index ] ) @@ -123,13 +123,13 @@ void rtems_cpu_usage_report_with_plugin( */ ran = the_thread->cpu_time_used; if ( _Thread_Executing->Object.id == the_thread->Object.id ) { - struct timespec used; - _Timespec_Subtract( + Timestamp_Control used; + _Timestamp_Subtract( &_Thread_Time_of_last_context_switch, &uptime, &used ); - _Timespec_Add_to( &ran, &used ); + _Timestamp_Add_to( &ran, &used ); }; - _Timespec_Divide( &ran, &total, &ival, &fval ); + _Timestamp_Divide( &ran, &total, &ival, &fval ); /* * Print the information @@ -137,7 +137,9 @@ void rtems_cpu_usage_report_with_plugin( (*print)( context, "%3" PRId32 ".%06" PRId32 " %3" PRId32 ".%03" PRId32 "\n", - ran.tv_sec, ran.tv_nsec / TOD_NANOSECONDS_PER_MICROSECOND, + _Timestamp_Get_seconds( &ran ), + _Timestamp_Get_nanoseconds( &ran ) / + TOD_NANOSECONDS_PER_MICROSECOND, ival, fval ); #else @@ -159,8 +161,8 @@ void rtems_cpu_usage_report_with_plugin( #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS (*print)( context, "Time since last CPU Usage reset %" PRId32 ".%06" PRId32 " seconds\n", - total.tv_sec, - total.tv_nsec / TOD_NANOSECONDS_PER_MICROSECOND + _Timestamp_Get_seconds( &total ), + _Timestamp_Get_nanoseconds( &total ) / TOD_NANOSECONDS_PER_MICROSECOND ); #else (*print)( context, diff --git a/cpukit/libmisc/cpuuse/cpuusagereset.c b/cpukit/libmisc/cpuuse/cpuusagereset.c index b6920702e1..233631dda2 100644 --- a/cpukit/libmisc/cpuuse/cpuusagereset.c +++ b/cpukit/libmisc/cpuuse/cpuusagereset.c @@ -16,6 +16,7 @@ #endif #include <rtems.h> +#include <rtems/score/timestamp.h> #include <stdlib.h> #include <ctype.h> @@ -28,8 +29,7 @@ static void CPU_usage_Per_thread_handler( ) { #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS - the_thread->cpu_time_used.tv_sec = 0; - the_thread->cpu_time_used.tv_nsec = 0; + _Timestamp_Set_to_zero( &the_thread->cpu_time_used ); #else the_thread->cpu_time_used = 0; #endif @@ -40,7 +40,7 @@ static void CPU_usage_Per_thread_handler( * External data that is shared by cpu usage code but not declared in .h files. */ #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS - extern struct timespec CPU_usage_Uptime_at_last_reset; + extern Timestamp_Control CPU_usage_Uptime_at_last_reset; #else extern uint32_t CPU_usage_Ticks_at_last_reset; #endif diff --git a/cpukit/posix/src/clockgettime.c b/cpukit/posix/src/clockgettime.c index d94bd16f98..8182f8e70f 100644 --- a/cpukit/posix/src/clockgettime.c +++ b/cpukit/posix/src/clockgettime.c @@ -36,22 +36,30 @@ int clock_gettime( if ( !tp ) rtems_set_errno_and_return_minus_one( EINVAL ); - if ( clock_id == CLOCK_REALTIME ) + if ( clock_id == CLOCK_REALTIME ) { _TOD_Get(tp); + return 0; + } #ifdef CLOCK_MONOTONIC - else if ( clock_id == CLOCK_MONOTONIC ) - _TOD_Get_uptime(tp); + if ( clock_id == CLOCK_MONOTONIC ) { + _TOD_Get_uptime_as_timespec( tp ); + return 0; + } #endif + #ifdef _POSIX_CPUTIME - else if ( clock_id == CLOCK_PROCESS_CPUTIME ) - _TOD_Get_uptime(tp); + if ( clock_id == CLOCK_PROCESS_CPUTIME ) { + _TOD_Get_uptime_as_timespec( tp ); + return 0; + } #endif + #ifdef _POSIX_THREAD_CPUTIME - else if ( clock_id == CLOCK_THREAD_CPUTIME ) + if ( clock_id == CLOCK_THREAD_CPUTIME ) rtems_set_errno_and_return_minus_one( ENOSYS ); #endif - else - rtems_set_errno_and_return_minus_one( EINVAL ); + + rtems_set_errno_and_return_minus_one( EINVAL ); return 0; } diff --git a/cpukit/posix/src/pthread.c b/cpukit/posix/src/pthread.c index 4a53d939be..d8aab727f2 100644 --- a/cpukit/posix/src/pthread.c +++ b/cpukit/posix/src/pthread.c @@ -31,6 +31,7 @@ #include <rtems/posix/config.h> #include <rtems/posix/key.h> #include <rtems/posix/time.h> +#include <rtems/score/timespec.h> /*PAGE * diff --git a/cpukit/posix/src/timersettime.c b/cpukit/posix/src/timersettime.c index 6099ae0400..eb7738a5b9 100644 --- a/cpukit/posix/src/timersettime.c +++ b/cpukit/posix/src/timersettime.c @@ -59,10 +59,12 @@ int timer_settime( /* Convert absolute to relative time */ if (flags == TIMER_ABSTIME) { + struct timespec now; + _TOD_Get( &now ); /* Check for seconds in the past */ - if ( _Timespec_Greater_than( &_TOD_Now, &normalize.it_value ) ) + if ( _Timespec_Greater_than( &now, &normalize.it_value ) ) rtems_set_errno_and_return_minus_one( EINVAL ); - _Timespec_Subtract( &_TOD_Now, &normalize.it_value, &normalize.it_value ); + _Timespec_Subtract( &now, &normalize.it_value, &normalize.it_value ); } /* If the function reaches this point, then it will be necessary to do diff --git a/cpukit/rtems/include/rtems/rtems/ratemon.h b/cpukit/rtems/include/rtems/rtems/ratemon.h index 41eb68ed31..3c5d1b65dc 100644 --- a/cpukit/rtems/include/rtems/rtems/ratemon.h +++ b/cpukit/rtems/include/rtems/rtems/ratemon.h @@ -70,7 +70,9 @@ extern "C" { * statistics. */ #if defined(RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS) - typedef struct timespec rtems_rate_monotonic_period_time_t; + #include <rtems/score/timestamp.h> + + typedef Timestamp_Control rtems_rate_monotonic_period_time_t; #else typedef uint32_t rtems_rate_monotonic_period_time_t; #endif @@ -382,8 +384,11 @@ void _Rate_monotonic_Timeout( #define _Rate_monotonic_Reset_wall_time_statistics( _the_period ) \ do { \ /* set the minimums to a large value */ \ - (_the_period)->Statistics.min_wall_time.tv_sec = 0x7fffffff; \ - (_the_period)->Statistics.min_wall_time.tv_nsec = 0x7fffffff; \ + _Timestamp_Set( \ + &(_the_period)->Statistics.min_wall_time, \ + 0x7fffffff, \ + 0x7fffffff \ + ); \ } while (0) #else #define _Rate_monotonic_Reset_wall_time_statistics( _the_period ) @@ -398,8 +403,11 @@ void _Rate_monotonic_Timeout( #define _Rate_monotonic_Reset_cpu_use_statistics( _the_period ) \ do { \ /* set the minimums to a large value */ \ - (_the_period)->Statistics.min_cpu_time.tv_sec = 0x7fffffff; \ - (_the_period)->Statistics.min_cpu_time.tv_nsec = 0x7fffffff; \ + _Timestamp_Set( \ + &(_the_period)->Statistics.min_cpu_time, \ + 0x7fffffff, \ + 0x7fffffff \ + ); \ } while (0) #else #define _Rate_monotonic_Reset_cpu_use_statistics( _the_period ) diff --git a/cpukit/rtems/src/clockgetsecondssinceepoch.c b/cpukit/rtems/src/clockgetsecondssinceepoch.c index 9c1badfe99..c8fcdc3183 100644 --- a/cpukit/rtems/src/clockgetsecondssinceepoch.c +++ b/cpukit/rtems/src/clockgetsecondssinceepoch.c @@ -33,6 +33,6 @@ rtems_status_code rtems_clock_get_seconds_since_epoch( if ( !_TOD_Is_set ) return RTEMS_NOT_DEFINED; - *the_interval = _TOD_Seconds_since_epoch; + *the_interval = _TOD_Seconds_since_epoch(); return RTEMS_SUCCESSFUL; } diff --git a/cpukit/rtems/src/clockgetuptime.c b/cpukit/rtems/src/clockgetuptime.c index 9fa88ef74b..9ac834c5f5 100644 --- a/cpukit/rtems/src/clockgetuptime.c +++ b/cpukit/rtems/src/clockgetuptime.c @@ -20,6 +20,7 @@ #include <rtems/rtems/clock.h> #include <rtems/score/isr.h> #include <rtems/score/thread.h> +#include <rtems/score/timestamp.h> #include <rtems/score/tod.h> #include <rtems/score/watchdog.h> @@ -45,6 +46,6 @@ rtems_status_code rtems_clock_get_uptime( if ( !uptime ) return RTEMS_INVALID_ADDRESS; - _TOD_Get_uptime( uptime ); + _TOD_Get_uptime_as_timespec( uptime ); return RTEMS_SUCCESSFUL; } diff --git a/cpukit/rtems/src/ratemongetstatus.c b/cpukit/rtems/src/ratemongetstatus.c index ef47a032e5..59b39e2917 100644 --- a/cpukit/rtems/src/ratemongetstatus.c +++ b/cpukit/rtems/src/ratemongetstatus.c @@ -65,14 +65,12 @@ rtems_status_code rtems_rate_monotonic_get_status( if ( status->state == RATE_MONOTONIC_INACTIVE ) { #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS - status->since_last_period.tv_sec = 0; - status->since_last_period.tv_nsec = 0; + _Timestamp_Set_to_zero( &status->since_last_period ); #else status->since_last_period = 0; #endif #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS - status->executed_since_last_period.tv_sec = 0; - status->executed_since_last_period.tv_nsec = 0; + _Timestamp_Set_to_zero( &status->executed_since_last_period ); #else status->executed_since_last_period = 0; #endif @@ -83,12 +81,12 @@ rtems_status_code rtems_rate_monotonic_get_status( */ #if defined(RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS) || \ defined(RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS) - struct timespec uptime; + Timestamp_Control uptime; _TOD_Get_uptime( &uptime ); #endif #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS - _Timespec_Subtract( + _Timestamp_Subtract( &the_period->time_at_period, &uptime, &status->since_last_period @@ -99,7 +97,7 @@ rtems_status_code rtems_rate_monotonic_get_status( #endif #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS - _Timespec_Subtract( + _Timestamp_Subtract( &_Thread_Time_of_last_context_switch, &uptime, &status->executed_since_last_period diff --git a/cpukit/rtems/src/ratemonperiod.c b/cpukit/rtems/src/ratemonperiod.c index 26db51f43b..db3b179e98 100644 --- a/cpukit/rtems/src/ratemonperiod.c +++ b/cpukit/rtems/src/ratemonperiod.c @@ -22,11 +22,6 @@ #include <rtems/score/object.h> #include <rtems/rtems/ratemon.h> #include <rtems/score/thread.h> -#if defined(RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS) || \ - defined(RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS) - #include <rtems/score/timespec.h> - extern struct timespec _Thread_Time_of_last_context_switch; -#endif void _Rate_monotonic_Update_statistics( Rate_monotonic_Control *the_period @@ -40,7 +35,7 @@ void _Rate_monotonic_Update_statistics( #endif #if defined(RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS) || \ defined(RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS) - struct timespec uptime; + Timestamp_Control uptime; /* * Obtain the current time since boot @@ -60,7 +55,7 @@ void _Rate_monotonic_Update_statistics( #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS period_start = the_period->time_at_period; - _Timespec_Subtract( &period_start, &uptime, &since_last_period ); + _Timestamp_Subtract( &period_start, &uptime, &since_last_period ); the_period->time_at_period = uptime; #else since_last_period = _Watchdog_Ticks_since_boot - the_period->time_at_period; @@ -75,17 +70,17 @@ void _Rate_monotonic_Update_statistics( used = _Thread_Executing->cpu_time_used; /* partial period, cpu usage info reset while executing. Throw away */ - if (_Timespec_Less_than( &used, &the_period->owner_executed_at_period)) + if (_Timestamp_Less_than( &used, &the_period->owner_executed_at_period)) return; /* How much time time since last context switch */ - _Timespec_Subtract(&_Thread_Time_of_last_context_switch, &uptime, &ran); + _Timestamp_Subtract(&_Thread_Time_of_last_context_switch, &uptime, &ran); /* executed += ran */ - _Timespec_Add_to( &used, &ran ); + _Timestamp_Add_to( &used, &ran ); /* executed = current cpu usage - value at start of period */ - _Timespec_Subtract( + _Timestamp_Subtract( &the_period->owner_executed_at_period, &used, &executed @@ -112,12 +107,12 @@ void _Rate_monotonic_Update_statistics( */ #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS - _Timespec_Add_to( &stats->total_cpu_time, &executed ); + _Timestamp_Add_to( &stats->total_cpu_time, &executed ); - if ( _Timespec_Less_than( &executed, &stats->min_cpu_time ) ) + if ( _Timestamp_Less_than( &executed, &stats->min_cpu_time ) ) stats->min_cpu_time = executed; - if ( _Timespec_Greater_than( &executed, &stats->max_cpu_time ) ) + if ( _Timestamp_Greater_than( &executed, &stats->max_cpu_time ) ) stats->max_cpu_time = executed; #else stats->total_cpu_time += executed; @@ -142,12 +137,12 @@ void _Rate_monotonic_Update_statistics( if ( since_last_period > stats->max_wall_time ) stats->max_wall_time = since_last_period; #else - _Timespec_Add_to( &stats->total_wall_time, &since_last_period ); + _Timestamp_Add_to( &stats->total_wall_time, &since_last_period ); - if ( _Timespec_Less_than( &since_last_period, &stats->min_wall_time ) ) + if ( _Timestamp_Less_than( &since_last_period, &stats->min_wall_time ) ) stats->min_wall_time = since_last_period; - if ( _Timespec_Greater_than( &since_last_period, &stats->max_wall_time ) ) + if ( _Timestamp_Greater_than( &since_last_period, &stats->max_wall_time ) ) stats->max_wall_time = since_last_period; #endif } @@ -211,7 +206,7 @@ rtems_status_code rtems_rate_monotonic_period( case RATE_MONOTONIC_INACTIVE: { #if defined(RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS) || \ defined(RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS) - struct timespec uptime; + Timestamp_Control uptime; #endif /* @@ -244,7 +239,7 @@ rtems_status_code rtems_rate_monotonic_period( _Thread_Executing->cpu_time_used; /* How much time time since last context switch */ - _Timespec_Subtract( + _Timestamp_Subtract( &_Thread_Time_of_last_context_switch, &uptime, &ran @@ -254,7 +249,7 @@ rtems_status_code rtems_rate_monotonic_period( * * the_period->owner_executed_at_period += ran */ - _Timespec_Add_to( &the_period->owner_executed_at_period, &ran ); + _Timestamp_Add_to( &the_period->owner_executed_at_period, &ran ); } #else the_period->owner_executed_at_period = diff --git a/cpukit/rtems/src/ratemonreportstatistics.c b/cpukit/rtems/src/ratemonreportstatistics.c index e8949f4b5e..02a0237faa 100644 --- a/cpukit/rtems/src/ratemonreportstatistics.c +++ b/cpukit/rtems/src/ratemonreportstatistics.c @@ -24,7 +24,7 @@ #if defined(RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS) || \ defined(RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS) - #include <rtems/score/timespec.h> + #include <rtems/score/timestamp.h> /* We print to 1/10's of milliseconds */ #define NANOSECONDS_DIVIDER 1000 @@ -149,23 +149,22 @@ ididididid NNNN ccccc mmmmmm X */ { #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS - struct timespec cpu_average; + Timestamp_Control cpu_average; + Timestamp_Control *min_cpu = &the_stats.min_cpu_time; + Timestamp_Control *max_cpu = &the_stats.max_cpu_time; + Timestamp_Control *total_cpu = &the_stats.total_cpu_time; - _Timespec_Divide_by_integer( - &the_stats.total_cpu_time, - the_stats.count, - &cpu_average - ); + _Timestamp_Divide_by_integer( total_cpu, the_stats.count, &cpu_average ); (*print)( context, "%" PRId32 "." NANOSECONDS_FMT "/" /* min cpu time */ "%" PRId32 "." NANOSECONDS_FMT "/" /* max cpu time */ "%" PRId32 "." NANOSECONDS_FMT " ", /* avg cpu time */ - the_stats.min_cpu_time.tv_sec, - the_stats.min_cpu_time.tv_nsec / NANOSECONDS_DIVIDER, - the_stats.max_cpu_time.tv_sec, - the_stats.max_cpu_time.tv_nsec / NANOSECONDS_DIVIDER, - cpu_average.tv_sec, - cpu_average.tv_nsec / NANOSECONDS_DIVIDER + _Timestamp_Get_seconds( min_cpu ), + _Timestamp_Get_nanoseconds( min_cpu ) / NANOSECONDS_DIVIDER, + _Timestamp_Get_seconds( max_cpu ), + _Timestamp_Get_nanoseconds( max_cpu ) / NANOSECONDS_DIVIDER, + _Timestamp_Get_seconds( &cpu_average ), + _Timestamp_Get_nanoseconds( &cpu_average ) / NANOSECONDS_DIVIDER ); #else uint32_t ival_cpu, fval_cpu; @@ -186,22 +185,22 @@ ididididid NNNN ccccc mmmmmm X */ { #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS - struct timespec wall_average; - _Timespec_Divide_by_integer( - &the_stats.total_wall_time, - the_stats.count, - &wall_average - ); + Timestamp_Control wall_average; + Timestamp_Control *min_wall = &the_stats.min_wall_time; + Timestamp_Control *max_wall = &the_stats.max_wall_time; + Timestamp_Control *total_wall = &the_stats.total_wall_time; + + _Timestamp_Divide_by_integer(total_wall, the_stats.count, &wall_average); (*print)( context, "%" PRId32 "." NANOSECONDS_FMT "/" /* min wall time */ "%" PRId32 "." NANOSECONDS_FMT "/" /* max wall time */ "%" PRId32 "." NANOSECONDS_FMT "\n", /* avg wall time */ - the_stats.min_wall_time.tv_sec, - the_stats.min_wall_time.tv_nsec / NANOSECONDS_DIVIDER, - the_stats.max_wall_time.tv_sec, - the_stats.max_wall_time.tv_nsec / NANOSECONDS_DIVIDER, - wall_average.tv_sec, - wall_average.tv_nsec / NANOSECONDS_DIVIDER + _Timestamp_Get_seconds( min_wall ), + _Timestamp_Get_nanoseconds( min_wall ) / NANOSECONDS_DIVIDER, + _Timestamp_Get_seconds( max_wall ), + _Timestamp_Get_nanoseconds( max_wall ) / NANOSECONDS_DIVIDER, + _Timestamp_Get_seconds( &wall_average ), + _Timestamp_Get_nanoseconds( &wall_average ) / NANOSECONDS_DIVIDER ); #else uint32_t ival_wall, fval_wall; diff --git a/cpukit/rtems/src/taskwakewhen.c b/cpukit/rtems/src/taskwakewhen.c index 96f7db2618..5496f55a73 100644 --- a/cpukit/rtems/src/taskwakewhen.c +++ b/cpukit/rtems/src/taskwakewhen.c @@ -67,7 +67,7 @@ rtems_status_code rtems_task_wake_when( seconds = _TOD_To_seconds( time_buffer ); - if ( seconds <= _TOD_Seconds_since_epoch ) + if ( seconds <= _TOD_Seconds_since_epoch() ) return RTEMS_INVALID_CLOCK; _Thread_Disable_dispatch(); @@ -80,7 +80,7 @@ rtems_status_code rtems_task_wake_when( ); _Watchdog_Insert_seconds( &_Thread_Executing->Timer, - seconds - _TOD_Seconds_since_epoch + seconds - _TOD_Seconds_since_epoch() ); _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; diff --git a/cpukit/rtems/src/timerfirewhen.c b/cpukit/rtems/src/timerfirewhen.c index bf1ffd568e..84ed3f6520 100644 --- a/cpukit/rtems/src/timerfirewhen.c +++ b/cpukit/rtems/src/timerfirewhen.c @@ -63,7 +63,7 @@ rtems_status_code rtems_timer_fire_when( return RTEMS_INVALID_ADDRESS; seconds = _TOD_To_seconds( wall_time ); - if ( seconds <= _TOD_Seconds_since_epoch ) + if ( seconds <= _TOD_Seconds_since_epoch() ) return RTEMS_INVALID_CLOCK; the_timer = _Timer_Get( id, &location ); @@ -75,7 +75,7 @@ rtems_status_code rtems_timer_fire_when( _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data ); _Watchdog_Insert_seconds( &the_timer->Ticker, - seconds - _TOD_Seconds_since_epoch + seconds - _TOD_Seconds_since_epoch() ); _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; diff --git a/cpukit/rtems/src/timerserver.c b/cpukit/rtems/src/timerserver.c index 9c4ea90b50..5f4b318e35 100644 --- a/cpukit/rtems/src/timerserver.c +++ b/cpukit/rtems/src/timerserver.c @@ -189,7 +189,7 @@ static void _Timer_Server_process_seconds_chain( * of Day (TOD) has not been set backwards. If it has then * we want to adjust the _Timer_Seconds_chain to indicate this. */ - snapshot = _TOD_Seconds_since_epoch; + snapshot = _TOD_Seconds_since_epoch(); if ( snapshot > _Timer_Server_seconds_last_time ) { /* * This path is for normal forward movement and cases where the @@ -232,7 +232,7 @@ Thread _Timer_Server_body( * the server was initiated. */ _Timer_Server_ticks_last_time = _Watchdog_Ticks_since_boot; - _Timer_Server_seconds_last_time = _TOD_Seconds_since_epoch; + _Timer_Server_seconds_last_time = _TOD_Seconds_since_epoch(); /* * Insert the timers that were inserted before we got to run. diff --git a/cpukit/rtems/src/timerserverfirewhen.c b/cpukit/rtems/src/timerserverfirewhen.c index a1f2caee6f..d8b503e274 100644 --- a/cpukit/rtems/src/timerserverfirewhen.c +++ b/cpukit/rtems/src/timerserverfirewhen.c @@ -67,7 +67,7 @@ rtems_status_code rtems_timer_server_fire_when( return RTEMS_INVALID_CLOCK; seconds = _TOD_To_seconds( wall_time ); - if ( seconds <= _TOD_Seconds_since_epoch ) + if ( seconds <= _TOD_Seconds_since_epoch() ) return RTEMS_INVALID_CLOCK; the_timer = _Timer_Get( id, &location ); @@ -77,7 +77,7 @@ rtems_status_code rtems_timer_server_fire_when( (void) _Watchdog_Remove( &the_timer->Ticker ); 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; + the_timer->Ticker.initial = seconds - _TOD_Seconds_since_epoch(); /* * _Timer_Server_schedule_operation != NULL because we checked that diff --git a/cpukit/score/Makefile.am b/cpukit/score/Makefile.am index ab38b23237..e2052efce4 100644 --- a/cpukit/score/Makefile.am +++ b/cpukit/score/Makefile.am @@ -29,10 +29,10 @@ include_rtems_score_HEADERS = include/rtems/score/address.h \ include/rtems/score/stack.h include/rtems/score/states.h \ include/rtems/score/sysstate.h include/rtems/score/thread.h \ include/rtems/score/threadq.h include/rtems/score/threadsync.h \ - include/rtems/score/timespec.h include/rtems/score/tod.h \ - include/rtems/score/tqdata.h include/rtems/score/userext.h \ - include/rtems/score/watchdog.h include/rtems/score/wkspace.h \ - include/rtems/score/cpuopts.h + include/rtems/score/timespec.h include/rtems/score/timestamp.h \ + include/rtems/score/tod.h include/rtems/score/tqdata.h \ + include/rtems/score/userext.h include/rtems/score/watchdog.h \ + include/rtems/score/wkspace.h include/rtems/score/cpuopts.h if HAS_MP # We only build multiprocessing related files if HAS_MP was defined @@ -169,7 +169,7 @@ libscore_a_SOURCES += src/timespecaddto.c src/timespecfromticks.c \ ## TOD_C_FILES libscore_a_SOURCES += src/coretod.c src/coretodset.c src/coretodget.c \ - src/coretodgetuptime.c src/coretodtickle.c + src/coretodgetuptime.c src/coretodgetuptimetimespec.c src/coretodtickle.c ## WATCHDOG_C_FILES libscore_a_SOURCES += src/watchdog.c src/watchdogadjust.c \ diff --git a/cpukit/score/include/rtems/score/thread.h b/cpukit/score/include/rtems/score/thread.h index fbfd971b23..ccdeb3df27 100644 --- a/cpukit/score/include/rtems/score/thread.h +++ b/cpukit/score/include/rtems/score/thread.h @@ -36,6 +36,8 @@ extern "C" { * resolution. */ #ifndef __RTEMS_USE_TICKS_CPU_USAGE_STATISTICS__ + #include <rtems/score/timestamp.h> + /** * This macro enables the nanosecond accurate statistics * @@ -44,7 +46,7 @@ extern "C" { */ #define RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS - typedef struct timespec rtems_thread_cpu_usage_t; + typedef Timestamp_Control rtems_thread_cpu_usage_t; #else typedef uint32_t rtems_thread_cpu_usage_t; @@ -500,7 +502,7 @@ SCORE_EXTERN struct _reent **_Thread_libc_reent; * system initialization and does not need to be known outside this * file. */ - SCORE_EXTERN struct timespec _Thread_Time_of_last_context_switch; + SCORE_EXTERN Timestamp_Control _Thread_Time_of_last_context_switch; #endif /** diff --git a/cpukit/score/include/rtems/score/timestamp.h b/cpukit/score/include/rtems/score/timestamp.h new file mode 100644 index 0000000000..0602c8d916 --- /dev/null +++ b/cpukit/score/include/rtems/score/timestamp.h @@ -0,0 +1,305 @@ +/** + * @file rtems/score/timestamp.h + * + * This include file contains helpers for manipulating timestamps. + */ + +/* + * COPYRIGHT (c) 1989-2008. + * 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.com/license/LICENSE. + * + * $Id$ + */ + +#ifndef _RTEMS_SCORE_TIMESTAMP_H +#define _RTEMS_SCORE_TIMESTAMP_H + +/** + * @defgroup SuperCore Timestamp + * + * This handler encapsulates functionality related to manipulating + * SuperCore Timestamps. SuperCore Timestamps may be used to + * represent time of day, uptime, or intervals. + * + * The key attribute of the SuperCore Timestamp handler is that it + * is a completely opaque handler. There can be multiple implementations + * of the required functionality and with a recompile, RTEMS can use + * any implementation. It is intended to be a simple wrapper. + * + * This handler can be implemented as either struct timespec or + * unsigned64 bit numbers. The use of a wrapper class allows the + * the implementation of timestamps to change on a per architecture + * basis. This is an important option as the performance of this + * handler is critical. + */ +/**@{*/ + +#ifdef __cplusplus +extern "C" { +#endif + +#include <rtems/score/timespec.h> + +#define RTEMS_SCORE_TIMESTAMP_IS_STRUCT_SPEC + +/** + * Define the Timestamp control type. + */ +#if defined(RTEMS_SCORE_TIMESTAMP_IS_STRUCT_SPEC) + typedef struct timespec Timestamp_Control; +#else + #error "No Alternative implementations for SuperCore Timestamp." +#endif + +/** @brief Set Timestamp to Seconds Nanosecond + * + * This method sets the timestamp to the specified seconds and nanoseconds + * value. + * + * @param[in] _time points to the timestamp instance to validate. + * @param[in] _seconds is the seconds portion of the timestamp + * @param[in] _nanoseconds is the nanoseconds portion of the timestamp + */ +#if defined(RTEMS_SCORE_TIMESTAMP_IS_STRUCT_SPEC) + #define _Timestamp_Set( _time, _seconds, _nanoseconds ) \ + do { \ + (_time)->tv_sec = (_seconds); \ + (_time)->tv_nsec = (_nanoseconds); \ + } while (0) +#endif + +/** @brief Zero Timestamp + * + * This method sets the timestamp to zero. + * value. + * + * @param[in] _time points to the timestamp instance to zero. + */ +#if defined(RTEMS_SCORE_TIMESTAMP_IS_STRUCT_SPEC) + #define _Timestamp_Set_to_zero( _time ) \ + do { \ + (_time)->tv_sec = 0; \ + (_time)->tv_nsec = 0; \ + } while (0) +#endif + +/** @brief Is Timestamp Valid + * + * This method determines the validity of a timestamp. + * + * @param[in] time is the timestamp instance to validate. + * + * @return This method returns true if @a time is valid and + * false otherwise. + */ +#if defined(RTEMS_SCORE_TIMESTAMP_IS_STRUCT_SPEC) + #define _Timestamp_Is_valid( _time ) \ + _Timespec_Is_valid( _time ) +#endif + +/** @brief Timestamp Less Than Operator + * + * This method is the less than operator for timestamps. + * + * @param[in] lhs is the left hand side timestamp + * @param[in] rhs is the right hand side timestamp + * + * @return This method returns true if @a lhs is less than the @a rhs and + * false otherwise. + */ +#if defined(RTEMS_SCORE_TIMESTAMP_IS_STRUCT_SPEC) + #define _Timestamp_Less_than( _lhs, _rhs ) \ + _Timespec_Less_than( _lhs, _rhs ) +#endif + +/** @brief Timestamp Greater Than Operator + * + * This method is the greater than operator for timestamps. + * + * @param[in] lhs is the left hand side timestamp + * @param[in] rhs is the right hand side timestamp + * + * @return This method returns true if @a lhs is greater than the @a rhs and + * false otherwise. + */ +#if defined(RTEMS_SCORE_TIMESTAMP_IS_STRUCT_SPEC) + #define _Timestamp_Greater_than( _lhs, _rhs ) \ + _Timespec_Greater_than( _lhs, _rhs ) +#endif + +/** @brief Timestamp equal to Operator + * + * This method is the is equal to than operator for timestamps. + * + * @param[in] lhs is the left hand side timestamp + * @param[in] rhs is the right hand side timestamp + * + * @return This method returns true if @a lhs is equal to @a rhs and + * false otherwise. + */ +#if defined(RTEMS_SCORE_TIMESTAMP_IS_STRUCT_SPEC) + #define _Timestamp_Equal_to( _lhs, _rhs ) \ + _Timespec_Equal_to( _lhs, _rhs ) +#endif + +/** @brief Add to a Timestamp + * + * This routine adds two timestamps. The second argument is added + * to the first. + * + * @param[in] time points to the base time to be added to + * @param[in] add points to the timestamp to add to the first argument + */ +#if defined(RTEMS_SCORE_TIMESTAMP_IS_STRUCT_SPEC) + #define _Timestamp_Add_to( _time, _add ) \ + _Timespec_Add_to( _time, _add ) +#endif + +/** @brief Add to a Timestamp (At Clock Tick) + * + * This routine adds two timestamps. The second argument is added + * to the first. + * + * @node This routine places a special requirement on the addition + * operation. It must return the number of units that the + * seconds field changed as the result of the addition. Since this + * operation is ONLY used as part of processing a clock tick, + * it is generally safe to assume that only one second changed. + * + * @param[in] time points to the base time to be added to + * @param[in] add points to the timestamp to add to the first argument + * + * @return This method returns the number of seconds @a time increased by. + */ +#if defined(RTEMS_SCORE_TIMESTAMP_IS_STRUCT_SPEC) + #define _Timestamp_Add_to_at_tick( _time, _add ) \ + _Timespec_Add_to( _time, _add ) +#endif + +/** @brief Convert Timestamp to Number of Ticks + * + * This routine convert the @a time timestamp to the corresponding number + * of clock ticks. + * + * @param[in] time points to the time to be converted + * + * @return This method returns the number of ticks computed. + */ +#if defined(RTEMS_SCORE_TIMESTAMP_IS_STRUCT_SPEC) + #define _Timestamp_To_ticks( _time ) \ + _Timespec_To_ticks( _time ) +#endif + +/** @brief Convert Ticks to Timestamp + * + * This routine converts the @a ticks value to the corresponding + * timestamp format @a time. + * + * @param[in] time points to the timestamp format time result + * @param[in] ticks points to the the number of ticks to be filled in + */ +#if defined(RTEMS_SCORE_TIMESTAMP_IS_STRUCT_SPEC) + #define _Timestamp_From_ticks( _ticks, _time ) \ + _Timespec_From_ticks( _ticks, _time ) +#endif + +/** @brief Subtract Two Timestamp + * + * This routine subtracts two timestamps. @a result is set to + * @a end - @a start. + * + * @param[in] start points to the starting time + * @param[in] end points to the ending time + * @param[in] result points to the difference between starting and ending time. + * + * @return This method fills in @a result. + */ +#if defined(RTEMS_SCORE_TIMESTAMP_IS_STRUCT_SPEC) + #define _Timestamp_Subtract( _start, _end, _result ) \ + _Timespec_Subtract( _start, _end, _result ) +#endif + +/** @brief Divide Timestamp By Integer + * + * This routine divides a timestamp by an integer value. The expected + * use is to assist in benchmark calculations where you typically + * divide a duration by a number of iterations. + * + * @param[in] time points to the total + * @param[in] iterations is the number of iterations + * @param[in] result points to the average time. + * + * @return This method fills in @a result. + */ +#if defined(RTEMS_SCORE_TIMESTAMP_IS_STRUCT_SPEC) + #define _Timestamp_Divide_by_integer( _time, _iterations, _result ) \ + _Timespec_Divide_by_integer(_time, _iterations, _result ) +#endif + +/** @brief Divide Timestamp + * + * This routine divides a timestamp by another timestamp. The + * intended use is for calculating percentages to three decimal points. + * + * @param[in] lhs points to the left hand number + * @param[in] rhs points to the right hand number + * @param[in] ival_percentage is the integer portion of the average + * @param[in] fval_percentage is the thousandths of percentage + * + * @return This method fills in @a result. + */ +#if defined(RTEMS_SCORE_TIMESTAMP_IS_STRUCT_SPEC) + #define _Timestamp_Divide( _lhs, _rhs, _ival_percentage, _fval_percentage ) \ + _Timespec_Divide( _lhs, _rhs, _ival_percentage, _fval_percentage ) +#endif + +/** @brief Get Seconds Portion of Timestamp + * + * This method returns the seconds portion of the specified timestamp + * + * @param[in] _time points to the timestamp + * + * @return The seconds portion of @a _time. + */ +#if defined(RTEMS_SCORE_TIMESTAMP_IS_STRUCT_SPEC) + #define _Timestamp_Get_seconds( _time ) \ + ((_time)->tv_sec) +#endif + +/** @brief Get Nanoseconds Portion of Timestamp + * + * This method returns the nanoseconds portion of the specified timestamp + * + * @param[in] _time points to the timestamp + * + * @return The nanoseconds portion of @a _time. + */ +#if defined(RTEMS_SCORE_TIMESTAMP_IS_STRUCT_SPEC) + #define _Timestamp_Get_nanoseconds( _time ) \ + ((_time)->tv_nsec) +#endif + +/** @brief Convert Timestamp to struct timespec + * + * This method returns the seconds portion of the specified timestamp + * + * @param[in] _timestamp points to the timestamp + * @param[in] _timespec points to the timespec + */ +#if defined(RTEMS_SCORE_TIMESTAMP_IS_STRUCT_SPEC) + #define _Timestamp_To_timespec( _timestamp, _timespec ) \ + *(_timespec) = *(_timestamp) +#endif + +#ifdef __cplusplus +} +#endif + +/**@}*/ + +#endif +/* end of include file */ diff --git a/cpukit/score/include/rtems/score/tod.h b/cpukit/score/include/rtems/score/tod.h index 6038b686d5..44d4df862e 100644 --- a/cpukit/score/include/rtems/score/tod.h +++ b/cpukit/score/include/rtems/score/tod.h @@ -23,7 +23,7 @@ extern "C" { #endif -#include <rtems/score/object.h> +#include <rtems/score/timestamp.h> #include <time.h> /** @defgroup ScoreTODConstants TOD Constants @@ -134,18 +134,19 @@ SCORE_EXTERN bool _TOD_Is_set; /** @brief Current Time of Day (Timespec) * The following contains the current time of day. */ -SCORE_EXTERN struct timespec _TOD_Now; +SCORE_EXTERN Timestamp_Control _TOD_Now; /** @brief Current Time of Day (Timespec) * The following contains the running uptime. */ -SCORE_EXTERN struct timespec _TOD_Uptime; +SCORE_EXTERN Timestamp_Control _TOD_Uptime; /** @brief Seconds Since RTEMS Epoch * The following contains the number of seconds from 00:00:00 * January 1, TOD_BASE_YEAR until the current time of day. */ -#define _TOD_Seconds_since_epoch (_TOD_Now.tv_sec) +#define _TOD_Seconds_since_epoch() \ + _Timestamp_Get_seconds(&_TOD_Now) /** @brief Microseconds per Clock Tick * @@ -189,6 +190,17 @@ void _TOD_Get( * @param[in] time is a pointer to the uptime to be returned */ void _TOD_Get_uptime( + Timestamp_Control *time +); + +/** @brief _TOD_Get_uptime_as_timespec + * + * This routine returns the system uptime with potential accuracy + * to the nanosecond. + * + * @param[in] time is a pointer to the uptime to be returned + */ +void _TOD_Get_uptime_as_timespec( struct timespec *time ); diff --git a/cpukit/score/preinstall.am b/cpukit/score/preinstall.am index cb27e47d48..af521fd10c 100644 --- a/cpukit/score/preinstall.am +++ b/cpukit/score/preinstall.am @@ -139,6 +139,10 @@ $(PROJECT_INCLUDE)/rtems/score/timespec.h: include/rtems/score/timespec.h $(PROJ $(INSTALL_DATA) $< $(PROJECT_INCLUDE)/rtems/score/timespec.h PREINSTALL_FILES += $(PROJECT_INCLUDE)/rtems/score/timespec.h +$(PROJECT_INCLUDE)/rtems/score/timestamp.h: include/rtems/score/timestamp.h $(PROJECT_INCLUDE)/rtems/score/$(dirstamp) + $(INSTALL_DATA) $< $(PROJECT_INCLUDE)/rtems/score/timestamp.h +PREINSTALL_FILES += $(PROJECT_INCLUDE)/rtems/score/timestamp.h + $(PROJECT_INCLUDE)/rtems/score/tod.h: include/rtems/score/tod.h $(PROJECT_INCLUDE)/rtems/score/$(dirstamp) $(INSTALL_DATA) $< $(PROJECT_INCLUDE)/rtems/score/tod.h PREINSTALL_FILES += $(PROJECT_INCLUDE)/rtems/score/tod.h diff --git a/cpukit/score/src/coretod.c b/cpukit/score/src/coretod.c index fbadaf673d..cf4ec8e334 100644 --- a/cpukit/score/src/coretod.c +++ b/cpukit/score/src/coretod.c @@ -41,12 +41,10 @@ void _TOD_Handler_initialization( _TOD_Microseconds_per_tick = microseconds_per_tick; /* POSIX format TOD (timespec) */ - _TOD_Now.tv_sec = TOD_SECONDS_1970_THROUGH_1988; - _TOD_Now.tv_nsec = 0; + _Timestamp_Set( &_TOD_Now, TOD_SECONDS_1970_THROUGH_1988, 0 ); /* Uptime (timespec) */ - _TOD_Uptime.tv_sec = 0; - _TOD_Uptime.tv_nsec = 0; + _Timestamp_Set_to_zero( &_TOD_Uptime ); /* TOD has not been set */ _TOD_Is_set = FALSE; diff --git a/cpukit/score/src/coretodget.c b/cpukit/score/src/coretodget.c index 1d48082f26..dff46a0748 100644 --- a/cpukit/score/src/coretodget.c +++ b/cpukit/score/src/coretodget.c @@ -18,6 +18,7 @@ #include <rtems/system.h> #include <rtems/score/isr.h> #include <rtems/score/timespec.h> +#include <rtems/score/timestamp.h> #include <rtems/score/tod.h> #include <rtems/score/watchdog.h> @@ -36,20 +37,22 @@ void _TOD_Get( struct timespec *time ) { - ISR_Level level; - struct timespec offset; + ISR_Level level; + Timestamp_Control offset; + Timestamp_Control now; + long nanoseconds; - /* assume time checked by caller */ + /* assume time checked for NULL by caller */ - offset.tv_sec = 0; - offset.tv_nsec = 0; - - /* _TOD_Now is a proper POSIX time */ + /* _TOD_Now is the native current time */ + nanoseconds = 0; _ISR_Disable( level ); - *time = _TOD_Now; + now = _TOD_Now; if ( _Watchdog_Nanoseconds_since_tick_handler ) - offset.tv_nsec = (*_Watchdog_Nanoseconds_since_tick_handler)(); + nanoseconds = (*_Watchdog_Nanoseconds_since_tick_handler)(); _ISR_Enable( level ); - _Timespec_Add_to( time, &offset ); + _Timestamp_Set( &offset, 0, nanoseconds ); + _Timestamp_Add_to( &now, &offset ); + _Timestamp_To_timespec( &now, time ); } diff --git a/cpukit/score/src/coretodgetuptime.c b/cpukit/score/src/coretodgetuptime.c index 7155419f34..6d4e5dc72a 100644 --- a/cpukit/score/src/coretodgetuptime.c +++ b/cpukit/score/src/coretodgetuptime.c @@ -18,7 +18,7 @@ #include <rtems/system.h> #include <rtems/score/isr.h> -#include <rtems/score/timespec.h> +#include <rtems/score/timestamp.h> #include <rtems/score/tod.h> #include <rtems/score/watchdog.h> @@ -28,28 +28,30 @@ * This routine is used to obtain the system uptime * * Input parameters: - * time - pointer to the time and date structure + * time - pointer to the timestamp structure * * Output parameters: NONE */ void _TOD_Get_uptime( - struct timespec *uptime + Timestamp_Control *uptime ) { - ISR_Level level; - struct timespec offset; + ISR_Level level; + Timestamp_Control offset; + Timestamp_Control up; + long nanoseconds; - /* assume uptime checked by caller */ - - offset.tv_sec = 0; - offset.tv_nsec = 0; + /* assume time checked for NULL by caller */ + /* _TOD_Uptime is in native timestamp format */ + nanoseconds = 0; _ISR_Disable( level ); - *uptime = _TOD_Uptime; + up= _TOD_Uptime; if ( _Watchdog_Nanoseconds_since_tick_handler ) - offset.tv_nsec = (*_Watchdog_Nanoseconds_since_tick_handler)(); + nanoseconds = (*_Watchdog_Nanoseconds_since_tick_handler)(); _ISR_Enable( level ); - _Timespec_Add_to( uptime, &offset ); + _Timestamp_Set( &offset, 0, nanoseconds ); + _Timestamp_Add_to( &up, &offset ); } diff --git a/cpukit/score/src/coretodgetuptimetimespec.c b/cpukit/score/src/coretodgetuptimetimespec.c new file mode 100644 index 0000000000..6d30a95d9c --- /dev/null +++ b/cpukit/score/src/coretodgetuptimetimespec.c @@ -0,0 +1,44 @@ +/* + * Time of Day (TOD) Handler - get uptime + */ + +/* COPYRIGHT (c) 1989-2008. + * 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.com/license/LICENSE. + * + * $Id$ + */ + +#if HAVE_CONFIG_H +#include "config.h" +#endif + +#include <rtems/system.h> +#include <rtems/score/isr.h> +#include <rtems/score/timestamp.h> +#include <rtems/score/tod.h> + +/* + * _TOD_Get_uptime_as_timespec + * + * This routine is used to obtain the system uptime + * + * Input parameters: + * time - pointer to the timestamp structure + * + * Output parameters: NONE + */ + +void _TOD_Get_uptime_as_timespec( + struct timespec *uptime +) +{ + Timestamp_Control uptime_ts; + + /* assume time checked for NULL by caller */ + _TOD_Get_uptime( &uptime_ts ); + _Timestamp_To_timespec( &uptime_ts, uptime ); +} diff --git a/cpukit/score/src/coretodset.c b/cpukit/score/src/coretodset.c index c34f571e30..fea26dd190 100644 --- a/cpukit/score/src/coretodset.c +++ b/cpukit/score/src/coretodset.c @@ -19,6 +19,7 @@ #include <rtems/system.h> #include <rtems/score/object.h> #include <rtems/score/thread.h> +#include <rtems/score/timestamp.h> #include <rtems/score/tod.h> #include <rtems/score/watchdog.h> @@ -39,19 +40,21 @@ void _TOD_Set( const struct timespec *time ) { + long seconds; + _Thread_Disable_dispatch(); _TOD_Deactivate(); - if ( time->tv_sec < _TOD_Seconds_since_epoch ) - _Watchdog_Adjust_seconds( WATCHDOG_BACKWARD, - _TOD_Seconds_since_epoch - time->tv_sec ); + seconds = _TOD_Seconds_since_epoch(); + + if ( time->tv_sec < seconds ) + _Watchdog_Adjust_seconds( WATCHDOG_BACKWARD, seconds - time->tv_sec ); else - _Watchdog_Adjust_seconds( WATCHDOG_FORWARD, - time->tv_sec - _TOD_Seconds_since_epoch ); + _Watchdog_Adjust_seconds( WATCHDOG_FORWARD, time->tv_sec - seconds ); /* POSIX format TOD (timespec) */ - _TOD_Now = *time; - _TOD_Is_set = TRUE; + _Timestamp_Set( &_TOD_Now, time->tv_sec, time->tv_nsec ); + _TOD_Is_set = TRUE; _TOD_Activate(); diff --git a/cpukit/score/src/coretodtickle.c b/cpukit/score/src/coretodtickle.c index 1afef420a2..f4e5a4f69c 100644 --- a/cpukit/score/src/coretodtickle.c +++ b/cpukit/score/src/coretodtickle.c @@ -19,7 +19,7 @@ #include <rtems/system.h> #include <rtems/score/object.h> #include <rtems/score/thread.h> -#include <rtems/score/timespec.h> +#include <rtems/score/timestamp.h> #include <rtems/score/tod.h> #include <rtems/score/watchdog.h> @@ -36,22 +36,21 @@ void _TOD_Tickle_ticks( void ) { - struct timespec tick; - uint32_t seconds; + Timestamp_Control tick; + uint32_t seconds; - /* Convert the tick quantum to a timespec */ - tick.tv_nsec = _TOD_Microseconds_per_tick * 1000; - tick.tv_sec = 0; + /* Convert the tick quantum to a timestamp */ + _Timestamp_Set( &tick, 0, _TOD_Microseconds_per_tick * 1000 ); /* Update the counter of ticks since boot */ _Watchdog_Ticks_since_boot += 1; /* Update the timespec format uptime */ - (void) _Timespec_Add_to( &_TOD_Uptime, &tick ); + _Timestamp_Add_to( &_TOD_Uptime, &tick ); /* we do not care how much the uptime changed */ /* Update the timespec format TOD */ - seconds = _Timespec_Add_to( &_TOD_Now, &tick ); + seconds = _Timestamp_Add_to_at_tick( &_TOD_Now, &tick ); while ( seconds ) { _Watchdog_Tickle_seconds(); seconds--; diff --git a/cpukit/score/src/threaddispatch.c b/cpukit/score/src/threaddispatch.c index 4911ab5342..45a4a45ebe 100644 --- a/cpukit/score/src/threaddispatch.c +++ b/cpukit/score/src/threaddispatch.c @@ -31,7 +31,7 @@ #include <rtems/score/wkspace.h> #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS - #include <rtems/score/timespec.h> + #include <rtems/score/timestamp.h> #endif /*PAGE @@ -103,10 +103,14 @@ void _Thread_Dispatch( void ) #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS { - struct timespec uptime, ran; + Timestamp_Control uptime, ran; _TOD_Get_uptime( &uptime ); - _Timespec_Subtract(&_Thread_Time_of_last_context_switch, &uptime, &ran); - _Timespec_Add_to( &executing->cpu_time_used, &ran ); + _Timestamp_Subtract( + &_Thread_Time_of_last_context_switch, + &uptime, + &ran + ); + _Timestamp_Add_to( &executing->cpu_time_used, &ran ); _Thread_Time_of_last_context_switch = uptime; } #else diff --git a/cpukit/score/src/threadinitialize.c b/cpukit/score/src/threadinitialize.c index 596fe365a0..b7e504ca4a 100644 --- a/cpukit/score/src/threadinitialize.c +++ b/cpukit/score/src/threadinitialize.c @@ -206,8 +206,7 @@ bool _Thread_Initialize( */ #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS - the_thread->cpu_time_used.tv_sec = 0; - the_thread->cpu_time_used.tv_nsec = 0; + _Timestamp_Set_to_zero( &the_thread->cpu_time_used ); #else the_thread->cpu_time_used = 0; #endif |