rtems_task Init(
rtems_task_argument argument
)
{
rtems_status_code status;
rtems_time_of_day time;
uint32_t ticks_per_second, ticks_since_boot;
puts( "\n\n\n*** PERIODIC TASKING TRIPLE TEST ***" );
puts( "*** This demo shows three different ways of running periodic tasks ***" );
puts( "*** It also demonstrates the CPU usage and Rate Monotonic statitistics utilities ***" );
rtems_clock_get( RTEMS_CLOCK_GET_TICKS_PER_SECOND, &ticks_per_second );
printf("\nTicks per second in your system: %" PRIu32 "\n", ticks_per_second);
rtems_clock_get( RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &ticks_since_boot );
printf("Ticks since boot: %" PRIu32 "\n\n", ticks_since_boot);
time.year = 1988;
time.month = 12;
time.day = 31;
time.hour = 9;
time.minute = 0;
time.second = 0;
time.ticks = 0;
status = rtems_clock_set( &time );
Task_name[ 1 ] = rtems_build_name( 'T', 'A', '1', ' ' );
Task_name[ 2 ] = rtems_build_name( 'T', 'A', '2', ' ' );
Task_name[ 3 ] = rtems_build_name( 'T', 'A', '3', ' ' );
// prototype: rtems_task_create( name, initial_priority, stack_size, initial_modes, attribute_set, *id );
status = rtems_task_create(
Task_name[ 1 ], 1, RTEMS_MINIMUM_STACK_SIZE * 2, RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES, &Task_id[ 1 ]
);
status = rtems_task_create(
Task_name[ 2 ], 1, RTEMS_MINIMUM_STACK_SIZE * 2, RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES, &Task_id[ 2 ]
);
status = rtems_task_create(
Task_name[ 3 ], 1, RTEMS_MINIMUM_STACK_SIZE * 2, RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES, &Task_id[ 3 ]
);
// prototype: rtems_task_start( id, entry_point, argument );
status = rtems_task_start( Task_id[ 1 ], Task_Absolute_Period, 1 );
status = rtems_task_start( Task_id[ 2 ], Task_Rate_Monotonic_Period, 2 );
status = rtems_task_start( Task_id[ 3 ], Task_Relative_Period, 3 );
// delete init task after starting the three working tasks
status = rtems_task_delete( RTEMS_SELF );
}
rtems_task Task_1_through_3(
rtems_task_argument argument
)
{
rtems_id tid;
rtems_time_of_day time;
rtems_status_code status;
status = rtems_task_ident( RTEMS_SELF, RTEMS_SEARCH_ALL_NODES, &tid );
directive_failed( status, "rtems_task_ident of self" );
while ( FOREVER ) {
status = rtems_timer_fire_after(
Timer_id[ argument ],
task_number( tid ) * 5 * TICKS_PER_SECOND,
Resume_task,
NULL
);
directive_failed( status, "tm_fire_after failed" );
status = rtems_clock_get( RTEMS_CLOCK_GET_TOD, &time );
directive_failed( status, "rtems_clock_get failed" );
if ( time.second >= 35 ) {
puts( "*** END OF TEST 24 ***" );
rtems_test_exit( 0 );
}
put_name( Task_name[ task_number( tid ) ], FALSE );
print_time( " - rtems_clock_get - ", &time, "\n" );
status = rtems_task_suspend( RTEMS_SELF );
directive_failed( status, "rtems_task_suspend" );
}
}
static void
getTimingInfo(void * arg) {
TscTestData *argp = (TscTestData *)arg;
rtems_interval tps;
int i;
double avg = 0.0;
double avgSqrs = 0.0;
double stdDev = 0.0;
double sdom = 0.0;
/*extern double tscTicksPerSecond;
extern double tscSdevTicksPerSecond;
extern double tscSdomTicksPerSecond;*/
/* skip the first delta: it'll be garbage anyway... */
for(i=1; i<argp->bufsize; i++) {
double tmp = (double)argp->buf[i];
avg += tmp;
avgSqrs += tmp*tmp;
}
#include <math.h>
stdDev = (1.0/(double)(i-2))*(avgSqrs - (1.0/(double)(i-1))*(avg*avg));
stdDev = sqrt(stdDev);
avg /= (double)(i-1);
sdom = stdDev/sqrt((double)(i-1));
rtems_clock_get(RTEMS_CLOCK_GET_TICKS_PER_SECOND,&tps);
syslog(LOG_INFO,"CPU frequency: avg=%.3f sdom=%.3f sigma=%.3f\n", avg*tps, sdom*tps, stdDev*tps);
/* set the globally accessible value in timeDefs.h */
tscTicksPerSecond = avg*tps;
tscSdevTicksPerSecond = stdDev*tps;
tscSdomTicksPerSecond = sdom*tps;
}
int
gesys_network_start()
{
char *buf;
#ifdef MULTI_NETDRIVER
printf("Going to probe for Ethernet chips when initializing networking:\n");
printf("(supported are 3c509 (ISA), 3c90x (PCI) and eepro100 (PCI) variants).\n");
printf("NOTES:\n");
printf(" - Initializing a 3c90x may take a LONG time (~1min); PLUS: it NEEDS media\n");
printf(" autonegotiation!\n");
printf(" - A BOOTP/DHCP server must supply my IF configuration\n");
printf(" (ip address, mask, [gateway, dns, ntp])\n");
#endif
#ifdef BSP_NETWORK_SETUP
{
extern int BSP_NETWORK_SETUP(struct rtems_bsdnet_config *, struct rtems_bsdnet_ifconfig *);
BSP_NETWORK_SETUP(&rtems_bsdnet_config, 0);
}
#endif
rtems_bsdnet_initialize_network();
/* remote logging only works after a call to openlog()... */
openlog(0, LOG_PID | LOG_CONS, 0); /* use RTEMS defaults */
#ifdef TFTP_SUPPORT
if (rtems_bsdnet_initialize_tftp_filesystem())
perror("TFTP FS initialization failed");
#endif
#ifdef NFS_SUPPORT
if ( rpcUdpInit() || nfsInit(0,0) )
/* nothing else to do */;
#endif
if ( rtems_bsdnet_ntpserver_count > 0 ) {
printf("Trying to synchronize NTP...");
fflush(stdout);
if (rtems_bsdnet_synchronize_ntp(0,0)<0)
printf("FAILED\n");
else
printf("OK\n");
rtems_time_of_day time;
rtems_clock_get(RTEMS_CLOCK_GET_TOD, &time);
printf("yr:%u m:%u d:%u hr:%u min:%u sec:%u\n",\
time.year,time.month,time.day,\
time.hour,time.minute,time.second);
fflush(stdout);
}
/* stuff command line 'name=value' pairs into the environment */
if ( (buf = strdup(rtems_bsdnet_bootp_cmdline)) ) {
cmdlinePairExtract(buf, putenv, 1);
free(buf);
}
return 0;
}
void setRealTimeFromRTEMS()
{
rtems_time_of_day rtems_tod;
rtems_clock_get( RTEMS_CLOCK_GET_TOD, &rtems_tod );
ICM7170_SetTOD( BSP_RTC_ADDRESS, BSP_RTC_FREQUENCY, &rtems_tod );
}
void Task_2_through_4()
{
ID tid;
int tid_index;
rtems_time_of_day time;
ER status;
char name[30];
status = get_tid( &tid );
directive_failed( status, "get_tid");
tid_index = tid - 1; /* account for init tasks */
sprintf(name, "TA%d", tid_index);
while( FOREVER ) {
status = rtems_clock_get( RTEMS_CLOCK_GET_TOD, &time );
directive_failed( status, "rtems_clock_get" );
if ( time.second >= 35 ) {
puts( "*** END OF ITRON TASK TEST 1 ***" );
rtems_test_exit( 0 );
}
printf(name);
print_time( " - rtems_clock_get - ", &time, "\n" );
status = rtems_task_wake_after( tid_index * 5 * TICKS_PER_SECOND );
directive_failed( status, "rtems_task_wake_after" );
}
}
/*-------------------------------------------------------------------------+
| Function: _IBMPC_inch_sleep
| Description: If charcter is ready return it, otherwise sleep until
| it is ready
| Global Variables: None.
| Arguments: None.
| Returns: character read from keyboard.
+--------------------------------------------------------------------------*/
char
_IBMPC_inch_sleep(void)
{
char c;
rtems_interval ticks_per_second;
ticks_per_second = 0;
for(;;)
{
if(_IBMPC_chrdy(&c))
{
return c;
}
if(ticks_per_second == 0)
{
rtems_clock_get(RTEMS_CLOCK_GET_TICKS_PER_SECOND,
&ticks_per_second);
}
rtems_task_wake_after((ticks_per_second+24)/25);
}
return c;
} /* _IBMPC_inch */
/* EPICS doesn't start up if the TOD is not initialized.
* Normally, this should be set from NTP but we use this
* as a fallback if NTP fails.
*
* FIXME: should read the RTC instead!.
*/
static void
dummy_clock_init()
{
rtems_time_of_day rt;
if ( RTEMS_SUCCESSFUL != rtems_clock_get( RTEMS_CLOCK_GET_TOD, &rt) ) {
rt.year = 2000;
rt.month = 1;
rt.day = 1;
rt.hour = 0;
rt.minute = 0;
rt.second = 0;
rt.ticks = 0;
rtems_clock_set(&rt);
}
}
rtems_task Tasks_Aperiodic(
rtems_task_argument argument
)
{
rtems_status_code status;
int start;
int stop;
int now;
put_name( Task_name[ argument ], FALSE );
status = rtems_task_wake_after( 2 + Phases[argument] );
directive_failed( status, "rtems_task_wake_after" );
if ( argument == 6 ) {
rtems_task_suspend( Task_id[5] );
rtems_task_resume( Task_id[5] );
}
rtems_clock_get(RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &start);
printf("AT%" PRIdPTR "-S ticks:%d\n", argument, start);
/* active computing */
while(FOREVER) {
rtems_clock_get(RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &now);
if (now >= start + Execution[argument]) break;
}
rtems_clock_get(RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &stop);
printf("P%" PRIdPTR "-F ticks:%d\n", argument, stop);
/* delete SELF */
fflush(stdout);
printf( "Killing task %" PRIdPTR "\n", argument);
status = rtems_task_delete(RTEMS_SELF);
directive_failed(status, "rtems_task_delete of RTEMS_SELF");
}
int checkRealTime()
{
rtems_time_of_day rtems_tod;
rtems_time_of_day rtc_tod;
ICM7170_GetTOD( BSP_RTC_ADDRESS, BSP_RTC_FREQUENCY, &rtc_tod );
rtems_clock_get( RTEMS_CLOCK_GET_TOD, &rtems_tod );
if( rtems_tod.year == rtc_tod.year &&
rtems_tod.month == rtc_tod.month &&
rtems_tod.day == rtc_tod.day ) {
return ((rtems_tod.hour - rtc_tod.hour) * 3600) +
((rtems_tod.minute - rtc_tod.minute) * 60) +
(rtems_tod.second - rtc_tod.second);
}
return 9999;
}
void setRealTimeFromRTEMS()
{
rtems_time_of_day t;
rtems_clock_get(RTEMS_CLOCK_GET_TOD,&t);
t.year -= 1900;
tod[0] |= 0x80; /* Stop write register */
setTod(7,t.year);
setTod(6,t.month);
setTod(5,t.day);
setTod(4,1); /* I don't know which day of week is */
setTod(3,t.hour);
setTod(2,t.minute);
setTod(1,t.second);
tod[0] &= 0x3f; /* Write these parameters */
}
int checkRealTime()
{
rtems_time_of_day t;
int d;
tod[0] |= 0x40; /* Stop read register */
rtems_clock_get(RTEMS_CLOCK_GET_TOD,&t);
if((t.year != 1900+getTod(7,0xff))
|| (t.month != getTod(6,0x1f))
|| (t.day != getTod(5,0x3f)))
d = 9999;
else
d = (t.hour-getTod(3,0x3f))*3600
+ (t.minute-getTod(3,0x7f))*60
+ (t.second - getTod(1,0x7f));
tod[1] &= 0x3f;
return d;
}
/** @brief Generate pseudo-random volume id.
*
* @param[out] volid_prt Pointer to volume ID.
*
* @return 0: OK.
* @return -1: Error occured. Errno is set to real error value.
*/
static int msdos_format_gen_volid
(
uint32_t *volid_ptr /* OUT */
)
{
int ret_val = 0;
int rc;
rtems_clock_time_value time_value;
rc = rtems_clock_get(RTEMS_CLOCK_GET_TIME_VALUE,&time_value);
if (rc == RTEMS_SUCCESSFUL) {
*volid_ptr = time_value.seconds + time_value.microseconds;
}
else {
*volid_ptr = rand();
}
return ret_val;
}
rtems_task Test_task(
rtems_task_argument unused
)
{
rtems_id tid;
rtems_time_of_day time;
uint32_t task_index;
rtems_status_code status;
status = rtems_task_ident( RTEMS_SELF, RTEMS_SEARCH_ALL_NODES, &tid );
task_index = task_number( tid );
for ( ; ; ) {
status = rtems_clock_get( RTEMS_CLOCK_GET_TOD, &time );
if ( time.second >= 35 ) {
puts( "*** END OF CLOCK TICK TEST ***" );
exit( 0 );
}
put_name( Task_name[ task_index ], FALSE );
print_time( " - rtems_clock_get - ", &time, "\n" );
status = rtems_task_wake_after( task_index * 5 * get_ticks_per_second() );
}
}
rtems_extension Task_switch(
rtems_tcb *unused,
rtems_tcb *heir
)
{
uint32_t index;
rtems_time_of_day time;
rtems_status_code status;
index = task_number( heir->Object.id );
switch( index ) {
case 1:
case 2:
case 3:
Run_count[ index ] += 1;
status = rtems_clock_get( RTEMS_CLOCK_GET_TOD, &time );
fatal_directive_status_with_level( status, RTEMS_SUCCESSFUL,
"rtems_clock_get", 1 );
if (taskSwitchLogIndex <
(sizeof taskSwitchLog / sizeof taskSwitchLog[0])) {
taskSwitchLog[taskSwitchLogIndex].taskIndex = index;
taskSwitchLog[taskSwitchLogIndex].when = time;
taskSwitchLogIndex++;
}
if ( time.second >= 16 )
testsFinished = 1;
break;
case 0:
default:
break;
}
}
rtems_task Task_1(
rtems_task_argument argument
)
{
rtems_name name RTEMS_GCC_NOWARN_UNUSED;
uint32_t index RTEMS_GCC_NOWARN_UNUSED;
rtems_id id RTEMS_GCC_NOWARN_UNUSED;
rtems_task_priority in_priority RTEMS_GCC_NOWARN_UNUSED;
rtems_task_priority out_priority RTEMS_GCC_NOWARN_UNUSED;
rtems_mode in_mode RTEMS_GCC_NOWARN_UNUSED;
rtems_mode mask RTEMS_GCC_NOWARN_UNUSED;
rtems_mode out_mode RTEMS_GCC_NOWARN_UNUSED;
rtems_time_of_day time RTEMS_GCC_NOWARN_UNUSED;
rtems_interval timeout RTEMS_GCC_NOWARN_UNUSED;
rtems_signal_set signals RTEMS_GCC_NOWARN_UNUSED;
void *address_1 RTEMS_GCC_NOWARN_UNUSED;
rtems_event_set events RTEMS_GCC_NOWARN_UNUSED;
long buffer[ 4 ] RTEMS_GCC_NOWARN_UNUSED;
uint32_t count RTEMS_GCC_NOWARN_UNUSED;
rtems_device_major_number major RTEMS_GCC_NOWARN_UNUSED;
rtems_device_minor_number minor RTEMS_GCC_NOWARN_UNUSED;
uint32_t io_result RTEMS_GCC_NOWARN_UNUSED;
uint32_t error RTEMS_GCC_NOWARN_UNUSED;
rtems_clock_get_options options RTEMS_GCC_NOWARN_UNUSED;
name = rtems_build_name( 'N', 'A', 'M', 'E' );
in_priority = 250;
in_mode = RTEMS_NO_PREEMPT;
mask = RTEMS_PREEMPT_MASK;
timeout = 100;
signals = RTEMS_SIGNAL_1 | RTEMS_SIGNAL_3;
major = 10;
minor = 0;
error = 100;
options = 0;
/* rtems_shutdown_executive */
benchmark_timer_initialize();
for ( index=1 ; index <= OPERATION_COUNT ; index++ )
(void) rtems_shutdown_executive( error );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_shutdown_executive",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_task_create */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_task_create(
name,
in_priority,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&id
);
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_task_create",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_task_ident */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_task_ident( name, RTEMS_SEARCH_ALL_NODES, id );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_task_ident",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_task_start */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_task_start( id, Task_1, 0 );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_task_start",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_task_restart */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_task_restart( id, 0 );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_task_restart",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_task_delete */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_task_delete( id );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_task_delete",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_task_suspend */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_task_suspend( id );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_task_suspend",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_task_resume */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_task_resume( id );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_task_resume",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_task_set_priority */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_task_set_priority( id, in_priority, &out_priority );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_task_set_priority",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_task_mode */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_task_mode( in_mode, mask, &out_mode );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_task_mode",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_task_wake_when */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_task_wake_when( time );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_task_wake_when",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_task_wake_after */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_task_wake_after( timeout );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_task_wake_after",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_interrupt_catch */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_interrupt_catch( Isr_handler, 5, address_1 );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_interrupt_catch",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_clock_get */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_clock_get( options, time );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_clock_get",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_clock_set */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_clock_set( time );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_clock_set",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_clock_tick */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_clock_tick();
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_clock_tick",
end_time,
OPERATION_COUNT,
overhead,
0
);
rtems_test_pause();
/* rtems_timer_create */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_timer_create( name, &id );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_timer_create",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_timer_delete */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_timer_delete( id );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_timer_delete",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_timer_ident */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_timer_ident( name, id );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_timer_ident",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_timer_fire_after */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_timer_fire_after(
id,
timeout,
Timer_handler,
NULL
);
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_timer_fire_after",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_timer_fire_when */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_timer_fire_when(
id,
time,
Timer_handler,
NULL
);
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_timer_fire_when",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_timer_reset */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_timer_reset( id );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_timer_reset",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_timer_cancel */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_timer_cancel( id );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_timer_cancel",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_semaphore_create */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_semaphore_create(
name,
128,
RTEMS_DEFAULT_ATTRIBUTES,
RTEMS_NO_PRIORITY,
&id
);
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_semaphore_create",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_semaphore_delete */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_semaphore_delete( id );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_semaphore_delete",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_semaphore_ident */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_semaphore_ident( name, RTEMS_SEARCH_ALL_NODES, id );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_semaphore_ident",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_semaphore_obtain */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_semaphore_obtain( id, RTEMS_DEFAULT_OPTIONS, timeout );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_semaphore_obtain",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_semaphore_release */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_semaphore_release( id );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_semaphore_release",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_message_queue_create */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_message_queue_create(
name,
128,
RTEMS_DEFAULT_ATTRIBUTES,
&id
);
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_message_queue_create",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_message_queue_ident */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_message_queue_ident(
name,
RTEMS_SEARCH_ALL_NODES,
id
);
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_message_queue_ident",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_message_queue_delete */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_message_queue_delete( id );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_message_queue_delete",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_message_queue_send */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_message_queue_send( id, (long (*)[4])buffer );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_message_queue_send",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_message_queue_urgent */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_message_queue_urgent( id, (long (*)[4])buffer );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_message_queue_urgent",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_message_queue_broadcast */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_message_queue_broadcast(
id,
(long (*)[4])buffer,
&count
);
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_message_queue_broadcast",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_message_queue_receive */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_message_queue_receive(
id,
(long (*)[4])buffer,
RTEMS_DEFAULT_OPTIONS,
timeout
);
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_message_queue_receive",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_message_queue_flush */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_message_queue_flush( id, &count );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_message_queue_flush",
end_time,
OPERATION_COUNT,
overhead,
0
);
rtems_test_pause();
/* rtems_event_send */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_event_send( id, events );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_event_send",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_event_receive */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_event_receive(
RTEMS_EVENT_16,
RTEMS_DEFAULT_OPTIONS,
timeout,
&events
);
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_event_receive",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_signal_catch */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_signal_catch( Asr_handler, RTEMS_DEFAULT_MODES );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_signal_catch",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_signal_send */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_signal_send( id, signals );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_signal_send",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_partition_create */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_partition_create(
name,
Memory_area,
2048,
128,
RTEMS_DEFAULT_ATTRIBUTES,
&id
);
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_partition_create",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_partition_ident */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_partition_ident( name, RTEMS_SEARCH_ALL_NODES, id );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_partition_ident",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_partition_delete */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_partition_delete( id );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_partition_delete",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_partition_get_buffer */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_partition_get_buffer( id, address_1 );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_partition_get_buffer",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_partition_return_buffer */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_partition_return_buffer( id, address_1 );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_partition_return_buffer",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_region_create */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_region_create(
name,
Memory_area,
2048,
128,
RTEMS_DEFAULT_ATTRIBUTES,
&id
);
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_region_create",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_region_ident */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_region_ident( name, id );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_region_ident",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_region_delete */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_region_delete( id );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_region_delete",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_region_get_segment */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_region_get_segment(
id,
243,
RTEMS_DEFAULT_OPTIONS,
timeout,
&address_1
);
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_region_get_segment",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_region_return_segment */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_region_return_segment( id, address_1 );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_region_return_segment",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_port_create */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_port_create(
name,
Internal_port_area,
External_port_area,
0xff,
&id
);
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_port_create",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_port_ident */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_port_ident( name, id );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_port_ident",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_port_delete */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_port_delete( id );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_port_delete",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_port_external_to_internal */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_port_external_to_internal(
id,
&External_port_area[ 7 ],
address_1
);
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_port_external_to_internal",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_port_internal_to_external */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_port_internal_to_external(
id,
&Internal_port_area[ 7 ],
address_1
);
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_port_internal_to_external",
end_time,
OPERATION_COUNT,
overhead,
0
);
rtems_test_pause();
/* rtems_io_initialize */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_io_initialize(
major,
minor,
address_1,
&io_result
);
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_io_initialize",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_io_open */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_io_open(
major,
minor,
address_1,
&io_result
);
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_io_open",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_io_close */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_io_close(
major,
minor,
address_1,
&io_result
);
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_io_close",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_io_read */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_io_read(
major,
minor,
address_1,
&io_result
);
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_io_read",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_io_write */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_io_write(
major,
minor,
address_1,
&io_result
);
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_io_write",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_io_control */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_io_control(
major,
minor,
address_1,
&io_result
);
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_io_control",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_fatal_error_occurred */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_fatal_error_occurred( error );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_fatal_error_occurred",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_rate_monotonic_create */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_rate_monotonic_create( name, &id );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_rate_monotonic_create",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_rate_monotonic_ident */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_rate_monotonic_ident( name, id );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_rate_monotonic_ident",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_rate_monotonic_delete */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_rate_monotonic_delete( id );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_rate_monotonic_delete",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_rate_monotonic_cancel */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_rate_monotonic_cancel( id );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_rate_monotonic_cancel",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_rate_monotonic_period */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_rate_monotonic_period( id, timeout );
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_rate_monotonic_period",
end_time,
OPERATION_COUNT,
overhead,
0
);
/* rtems_multiprocessing_announce */
benchmark_timer_initialize();
for ( index = 1 ; index <= OPERATION_COUNT ; index ++ )
(void) rtems_multiprocessing_announce();
end_time = benchmark_timer_read();
put_time(
"overhead: rtems_multiprocessing_announce",
end_time,
OPERATION_COUNT,
overhead,
0
);
TEST_END();
rtems_test_exit( 0 );
}
rtems_task FP_task(
rtems_task_argument argument
)
{
rtems_status_code status;
rtems_id tid;
rtems_time_of_day time;
uint32_t task_index;
uint32_t previous_seconds;
INTEGER_DECLARE;
FP_DECLARE;
status = rtems_task_ident( RTEMS_SELF, RTEMS_SEARCH_ALL_NODES, &tid );
directive_failed( status, "rtems_task_ident of self" );
task_index = task_number( tid );
INTEGER_LOAD( INTEGER_factors[ task_index ] );
FP_LOAD( FP_factors[ task_index ] );
put_name( Task_name[ task_index ], FALSE );
printf( " - integer base = (0x%x)\n", INTEGER_factors[ task_index ] );
put_name( Task_name[ task_index ], FALSE );
#if ( RTEMS_HAS_HARDWARE_FP == 1 )
printf( " - float base = (%g)\n", FP_factors[ task_index ] );
#else
printf( " - float base = (NA)\n" );
#endif
previous_seconds = -1;
while( FOREVER ) {
status = rtems_clock_get( RTEMS_CLOCK_GET_TOD, &time );
directive_failed( status, "rtems_clock_get" );
if ( time.second >= 16 ) {
if ( task_number( tid ) == 4 ) {
puts( "TA4 - rtems_task_delete - self" );
status = rtems_task_delete( RTEMS_SELF );
directive_failed( status, "rtems_task_delete of TA4" );
}
puts( "TA5 - rtems_task_delete - TA3" );
status = rtems_task_delete( Task_id[ 3 ] );
directive_failed( status, "rtems_task_delete of TA3" );
puts( "*** END OF TEST 19 *** " );
rtems_test_exit( 0 );
}
if (previous_seconds != time.second)
{
put_name( Task_name[ task_index ], FALSE );
print_time( " - rtems_clock_get - ", &time, "\n" );
previous_seconds = time.second;
}
INTEGER_CHECK( INTEGER_factors[ task_index ] );
FP_CHECK( FP_factors[ task_index ] );
/* for the first 4 seconds we spin as fast as possible
* so that we likely are interrupted
* After that, we go to sleep for a second at a time
*/
if (time.second >= 4)
{
status = rtems_task_wake_after( TICKS_PER_SECOND );
directive_failed( status, "rtems_task_wake_after" );
}
}
}
rtems_task Task_Periodic(
rtems_task_argument argument
)
{
rtems_id rmid;
rtems_status_code status;
time_t approved_budget, exec_time, abs_time, current_budget;
int start, stop, now;
qres_sid_t server_id, tsid;
qres_params_t params, tparams;
params.P = Period;
params.Q = Execution+1;
printf( "Periodic task: Create server and Attach thread\n" );
if ( qres_create_server( ¶ms, &server_id ) )
printf( "ERROR: CREATE SERVER FAILED\n" );
if ( qres_attach_thread( server_id, 0, Task_id ) )
printf( "ERROR: ATTACH THREAD FAILED\n" );
printf( "Periodic task: ID and Get parameters\n" );
if ( qres_get_sid( 0, Task_id, &tsid ) )
printf( "ERROR: GET SERVER ID FAILED\n" );
if ( tsid != server_id )
printf( "ERROR: SERVER ID MISMATCH\n" );
if ( qres_get_params( server_id, &tparams ) )
printf( "ERROR: GET PARAMETERS FAILED\n" );
if ( params.P != tparams.P ||
params.Q != tparams.Q )
printf( "ERROR: PARAMETERS MISMATCH\n" );
printf( "Periodic task: Detach thread and Destroy server\n" );
if ( qres_detach_thread( server_id, 0, Task_id ) )
printf( "ERROR: DETACH THREAD FAILED\n" );
if ( qres_destroy_server( server_id ) )
printf( "ERROR: DESTROY SERVER FAILED\n" );
if ( qres_create_server( ¶ms, &server_id ) )
printf( "ERROR: CREATE SERVER FAILED\n" );
printf( "Periodic task: Current budget and Execution time\n" );
if ( qres_get_curr_budget( server_id, ¤t_budget ) )
printf( "ERROR: GET REMAINING BUDGET FAILED\n" );
if ( current_budget != params.Q )
printf( "ERROR: REMAINING BUDGET MISMATCH\n" );
if ( qres_get_exec_time( server_id, &exec_time, &abs_time ) )
printf( "ERROR: GET EXECUTION TIME FAILED\n" );
printf( "Periodic task: Set parameters\n" );
if ( qres_attach_thread( server_id, 0, Task_id ) )
printf( "ERROR: ATTACH THREAD FAILED\n" );
params.P = Period * 2;
params.Q = Execution * 2 +1;
if ( qres_set_params( server_id, ¶ms ) )
printf( "ERROR: SET PARAMS FAILED\n" );
if ( qres_get_params( server_id, &tparams ) )
printf( "ERROR: GET PARAMS FAILED\n" );
if ( params.P != tparams.P ||
params.Q != tparams.Q )
printf( "ERROR: PARAMS MISMATCH\n" );
params.P = Period;
params.Q = Execution+1;
if ( qres_set_params( server_id, ¶ms ) )
printf( "ERROR: SET PARAMS FAILED\n" );
if ( qres_get_appr_budget( server_id, &approved_budget ) )
printf( "ERROR: GET APPROVED BUDGET FAILED\n" );
printf( "Periodic task: Approved budget\n" );
if ( approved_budget != params.Q )
printf( "ERROR: APPROVED BUDGET MISMATCH\n" );
status = rtems_rate_monotonic_create( argument, &rmid );
directive_failed( status, "rtems_rate_monotonic_create" );
/* Starting periodic behavior of the task */
printf( "Periodic task: Starting periodic behavior\n" );
status = rtems_task_wake_after( 1 + Phase );
directive_failed( status, "rtems_task_wake_after" );
while ( FOREVER ) {
if ( rtems_rate_monotonic_period(rmid, Period) == RTEMS_TIMEOUT )
printf( "P%" PRIdPTR " - Deadline miss\n", argument );
rtems_clock_get( RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &start );
printf( "P%" PRIdPTR "-S ticks:%d\n", argument, start );
if ( start > 4*Period+Phase ) break; /* stop */
/* active computing */
while(FOREVER) {
rtems_clock_get( RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &now );
if ( now >= start + Execution ) break;
if ( qres_get_exec_time( server_id, &exec_time, &abs_time ) )
printf( "ERROR: GET EXECUTION TIME FAILED\n" );
if ( qres_get_curr_budget( server_id, ¤t_budget) )
printf( "ERROR: GET CURRENT BUDGET FAILED\n" );
if ( (current_budget + exec_time) > (Execution + 1) ) {
printf( "ERROR: CURRENT BUDGET AND EXECUTION TIME MISMATCH\n" );
rtems_test_exit( 0 );
}
}
rtems_clock_get( RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &stop );
printf( "P%" PRIdPTR "-F ticks:%d\n", argument, stop );
}
/* delete period and SELF */
status = rtems_rate_monotonic_delete( rmid );
if ( status != RTEMS_SUCCESSFUL ) {
printf("rtems_rate_monotonic_delete failed with status of %d.\n", status);
rtems_test_exit( 0 );
}
if ( qres_cleanup() )
printf( "ERROR: QRES CLEANUP\n" );
fflush(stdout);
puts( "*** END OF TEST QRES LIBRARY ***" );
rtems_test_exit( 0 );
}
int __po_hi_get_time (__po_hi_time_t* mytime)
{
#if defined (POSIX) || defined (RTEMS_POSIX) || defined (XENO_POSIX)
struct timespec ts;
#ifdef __MACH__ // OS X does not have clock_gettime, use clock_get_time
clock_serv_t cclock;
mach_timespec_t mts;
host_get_clock_service(mach_host_self(), CALENDAR_CLOCK, &cclock);
clock_get_time(cclock, &mts);
mach_port_deallocate(mach_task_self(), cclock);
ts.tv_sec = mts.tv_sec;
ts.tv_nsec = mts.tv_nsec;
#else
if (clock_gettime (CLOCK_REALTIME, &ts)!=0)
{
return (__PO_HI_ERROR_CLOCK);
}
#endif
mytime->sec = ts.tv_sec;
mytime->nsec = ts.tv_nsec;
return (__PO_HI_SUCCESS);
#elif defined (_WIN32)
SYSTEMTIME st;
FILETIME ft;
LARGE_INTEGER ularge;
GetSystemTime(&st);
SystemTimeToFileTime(&st,&ft);
ularge.LowPart=ft.dwLowDateTime;
ularge.HighPart=ft.dwHighDateTime;
mytime->sec = __po_hi_windows_tick_to_unix_seconds (ularge.QuadPart);
mytime->nsec = ularge.QuadPart % 10000000;
mytime->nsec *= 100;
return (__PO_HI_SUCCESS);
#elif defined (RTEMS_PURE)
rtems_time_of_day current_time;
if (rtems_clock_get (RTEMS_CLOCK_GET_TOD, ¤t_time) != RTEMS_SUCCESSFUL)
{
__DEBUGMSG ("Error when trying to get the clock on RTEMS\n");
}
mytime->sec = _TOD_To_seconds (¤t_time);
mytime->nsec = current_time.ticks * rtems_configuration_get_microseconds_per_tick() * 1000;
return (__PO_HI_SUCCESS);
#elif defined (XENO_NATIVE)
mytime->sec = rt_timer_tsc2ns (rt_timer_read ()) / 1000000000;
mytime->nsec = rt_timer_tsc2ns (rt_timer_read ()) - (mytime->sec * 1000000000);
return (__PO_HI_SUCCESS);
#else
return (__PO_HI_UNAVAILABLE);
#endif
}
/*
* RTEMS Startup task
*/
rtems_task
Init (rtems_task_argument ignored)
{
int i;
char *argv[3] = { NULL, NULL, NULL };
char *cp;
rtems_task_priority newpri;
rtems_status_code sc;
rtems_time_of_day now;
/*
* Explain why we're here
*/
logReset();
/*
* Architecture-specific hooks
*/
if (epicsRtemsInitPreSetBootConfigFromNVRAM(&rtems_bsdnet_config) != 0)
delayedPanic("epicsRtemsInitPreSetBootConfigFromNVRAM");
if (rtems_bsdnet_config.bootp == NULL) {
extern void setBootConfigFromNVRAM(void);
setBootConfigFromNVRAM();
}
if (epicsRtemsInitPostSetBootConfigFromNVRAM(&rtems_bsdnet_config) != 0)
delayedPanic("epicsRtemsInitPostSetBootConfigFromNVRAM");
/*
* Override RTEMS configuration
*/
rtems_task_set_priority (
RTEMS_SELF,
epicsThreadGetOssPriorityValue(epicsThreadPriorityIocsh),
&newpri);
/*
* Create a reasonable environment
*/
initConsole ();
putenv ("TERM=xterm");
putenv ("IOCSH_HISTSIZE=20");
/*
* Display some OS information
*/
printf("\n***** RTEMS Version: %s *****\n",
rtems_get_version_string());
/*
* Start network
*/
if ((cp = getenv("EPICS_TS_NTP_INET")) != NULL)
rtems_bsdnet_config.ntp_server[0] = cp;
if (rtems_bsdnet_config.network_task_priority == 0)
{
unsigned int p;
if (epicsThreadHighestPriorityLevelBelow(epicsThreadPriorityScanLow, &p)
== epicsThreadBooleanStatusSuccess)
{
rtems_bsdnet_config.network_task_priority = epicsThreadGetOssPriorityValue(p);
}
}
printf("\n***** Initializing network *****\n");
rtems_bsdnet_initialize_network();
initialize_remote_filesystem(argv, initialize_local_filesystem(argv));
/*
* More environment: iocsh prompt and hostname
*/
{
char hostname[1024];
gethostname(hostname, 1023);
char *cp = mustMalloc(strlen(hostname)+3, "iocsh prompt");
sprintf(cp, "%s> ", hostname);
epicsEnvSet ("IOCSH_PS1", cp);
epicsEnvSet("IOC_NAME", hostname);
}
/*
* Use BSP-supplied time of day if available otherwise supply default time.
* It is very likely that other time synchronization facilities in EPICS
* will soon override this value.
*/
if (rtems_clock_get(RTEMS_CLOCK_GET_TOD,&now) != RTEMS_SUCCESSFUL) {
now.year = 2001;
now.month = 1;
now.day = 1;
now.hour = 0;
now.minute = 0;
now.second = 0;
now.ticks = 0;
if ((sc = rtems_clock_set (&now)) != RTEMS_SUCCESSFUL)
printf ("***** Can't set time: %s\n", rtems_status_text (sc));
}
if (getenv("TZ") == NULL) {
const char *tzp = envGetConfigParamPtr(&EPICS_TIMEZONE);
if (tzp == NULL) {
printf("Warning -- no timezone information available -- times will be displayed as GMT.\n");
}
else {
char tz[10];
int minWest, toDst = 0, fromDst = 0;
if(sscanf(tzp, "%9[^:]::%d:%d:%d", tz, &minWest, &toDst, &fromDst) < 2) {
printf("Warning: EPICS_TIMEZONE (%s) unrecognizable -- times will be displayed as GMT.\n", tzp);
}
else {
char posixTzBuf[40];
char *p = posixTzBuf;
p += sprintf(p, "%cST%d:%.2d", tz[0], minWest/60, minWest%60);
if (toDst != fromDst)
p += sprintf(p, "%cDT", tz[0]);
epicsEnvSet("TZ", posixTzBuf);
}
}
}
tzset();
osdTimeRegister();
/*
* Run the EPICS startup script
*/
printf ("***** Starting EPICS application *****\n");
iocshRegisterRTEMS ();
set_directory (argv[1]);
epicsEnvSet ("IOC_STARTUP_SCRIPT", argv[1]);
atexit(exitHandler);
i = main ((sizeof argv / sizeof argv[0]) - 1, argv);
printf ("***** IOC application terminating *****\n");
epicsThreadSleep(1.0);
epicsExit(0);
}
rtems_task Task_2(
rtems_task_argument argument
)
{
rtems_event_set eventout;
rtems_time_of_day time;
rtems_status_code status;
status = rtems_task_wake_after( 1*TICKS_PER_SECOND );
directive_failed( status, "rtems_task_wake_after" );
puts( "TA2 - rtems_event_receive - waiting forever on RTEMS_EVENT_16" );
status = rtems_event_receive(
RTEMS_EVENT_16,
RTEMS_DEFAULT_OPTIONS,
RTEMS_NO_TIMEOUT,
&eventout
);
directive_failed( status, "rtems_event_receive" );
printf( "TA2 - RTEMS_EVENT_16 received - eventout => %08x\n", eventout );
puts(
"TA2 - rtems_event_send - send RTEMS_EVENT_14 and RTEMS_EVENT_15 to TA1"
);
status = rtems_event_send( Task_id[ 1 ], RTEMS_EVENT_14 | RTEMS_EVENT_15 );
directive_failed( status, "rtems_event_send" );
puts(
"TA2 - rtems_event_receive - RTEMS_EVENT_17 or "
"RTEMS_EVENT_18 - forever and ANY"
);
status = rtems_event_receive(
RTEMS_EVENT_17 | RTEMS_EVENT_18,
RTEMS_EVENT_ANY,
RTEMS_NO_TIMEOUT,
&eventout
);
directive_failed( status, "rtems_event_receive" );
printf(
"TA2 - RTEMS_EVENT_17 or RTEMS_EVENT_18 received - eventout => %08x\n",
eventout
);
puts( "TA2 - rtems_event_send - send RTEMS_EVENT_14 to TA1" );
status = rtems_event_send( Task_id[ 1 ], RTEMS_EVENT_14 );
directive_failed( status, "rtems_event_send" );
build_time( &time, 2, 12, 1988, 8, 15, 0, 0 );
print_time( "TA2 - rtems_clock_set - ", &time, "\n" );
status = rtems_clock_set( &time );
directive_failed( status, "TA2 rtems_clock_set" );
time.second += 4;
puts(
"TA2 - rtems_event_send - sending RTEMS_EVENT_10 to self after 4 seconds"
);
status = rtems_timer_fire_when(
Timer_id[ 5 ],
&time,
TA2_send_10_to_self,
NULL
);
directive_failed( status, "rtems_timer_fire_when after 4 seconds" );
puts( "TA2 - rtems_event_receive - waiting forever on RTEMS_EVENT_10" );
status = rtems_event_receive(
RTEMS_EVENT_10,
RTEMS_DEFAULT_OPTIONS,
RTEMS_NO_TIMEOUT,
&eventout
);
directive_failed( status, "rtems_event_receive" );
status = rtems_clock_get( RTEMS_CLOCK_GET_TOD, &time );
directive_failed( status, "rtems_clock_get" );
printf( "TA2 - RTEMS_EVENT_10 received - eventout => %08x\n", eventout );
print_time( "TA2 - rtems_clock_get - ", &time, "\n" );
puts( "TA2 - rtems_event_receive - RTEMS_PENDING_EVENTS" );
status = rtems_event_receive(
RTEMS_PENDING_EVENTS,
RTEMS_DEFAULT_OPTIONS,
RTEMS_NO_TIMEOUT,
&eventout
);
directive_failed( status, "rtems_event_receive" );
printf( "TA2 - eventout => %08x\n", eventout );
puts( "TA2 - rtems_event_receive - RTEMS_EVENT_19 - RTEMS_NO_WAIT" );
status = rtems_event_receive(
RTEMS_EVENT_19,
RTEMS_NO_WAIT,
RTEMS_NO_TIMEOUT,
&eventout
);
directive_failed( status, "rtems_event_receive" );
printf( "TA2 - RTEMS_EVENT_19 received - eventout => %08x\n", eventout );
puts( "TA2 - rtems_task_delete - deletes self" );
status = rtems_task_delete( Task_id[ 2 ] );
directive_failed( status, "rtems_task_delete of TA2" );
}
void fileio_list_file(void)
{
char fname[1024];
char *buf_ptr = NULL;
ssize_t flen = 0;
int fd = -1;
ssize_t n;
size_t buf_size = 100;
rtems_interval start_tick,curr_tick,ticks_per_sec;
printf(" =========================\n");
printf(" LIST FILE ... \n");
printf(" =========================\n");
fileio_print_free_heap();
printf(" Enter filename to list ==>");
fflush(stdout);
fgets(fname,sizeof(fname)-1,stdin);
while (fname[strlen(fname)-1] == '\n') {
fname[strlen(fname)-1] = '\0';
}
/*
* allocate buffer of given size
*/
if (buf_size > 0) {
buf_ptr = malloc(buf_size);
}
if (buf_ptr != NULL) {
printf("\n Trying to open file \"%s\" for read\n",fname);
fd = open(fname,O_RDONLY);
if (fd < 0) {
printf("*** file open failed, errno = %d(%s)\n",errno,strerror(errno));
}
}
if (fd >= 0) {
rtems_clock_get (RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &start_tick);
do {
n = read(fd,buf_ptr,buf_size);
if (n > 0) {
write(1,buf_ptr,n);
flen += n;
}
} while (n > 0);
rtems_clock_get (RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &curr_tick);
printf("\n ******** End of file reached, flen = %d\n",flen);
close(fd);
rtems_clock_get(RTEMS_CLOCK_GET_TICKS_PER_SECOND, &ticks_per_sec);
printf("time elapsed for read: %g seconds\n",
((double)curr_tick-start_tick)/ticks_per_sec);
}
/*
* free buffer
*/
if (buf_ptr != NULL) {
free(buf_ptr);
}
fileio_print_free_heap();
}
rtems_task Init(
rtems_task_argument ignored
)
{
rtems_status_code sc;
rtems_time_of_day time;
rtems_interval interval;
struct timeval timev;
puts( "\n\n*** TEST LEGACY RTEMS_CLOCK_GET ***" );
puts( "Init - clock_set_time" );
build_time( &time, 12, 31, 1988, 9, 0, 0, 0 );
sc = rtems_clock_set( &time );
directive_failed( sc, "rtems_clock_set" );
/* NULL parameter */
sc = rtems_clock_get( RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, NULL );
fatal_directive_status( sc, RTEMS_INVALID_ADDRESS, "null pointer" );
puts( "TA1 - rtems_clock_get - RTEMS_INVALID_ADDRESS" );
/* arbitrary bad value for switch */
sc = rtems_clock_get( 0xff, &timev );
fatal_directive_status( sc, RTEMS_INVALID_NUMBER, "bad case" );
puts( "TA1 - rtems_clock_get - RTEMS_INVALID_NUMBER" );
sc = rtems_clock_get( RTEMS_CLOCK_GET_TOD, &time );
directive_failed( sc, "rtems_clock_get -- TOD" );
print_time( "Init - rtems_clock_get - ", &time, "\n" );
sc = rtems_clock_get( RTEMS_CLOCK_GET_SECONDS_SINCE_EPOCH, &interval );
directive_failed( sc, "rtems_clock_get -- Seconds Since Epoch" );
printf(
"Init - rtems_clock_get - Seconds Since Epoch = %" PRIdrtems_interval "\n",
interval
);
sc = rtems_clock_get( RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &interval );
directive_failed( sc, "rtems_clock_get -- Ticks Since Boot" );
printf(
"Init - rtems_clock_get - Ticks Since Boot = %" PRIdrtems_interval "\n",
interval
);
sc = rtems_clock_get( RTEMS_CLOCK_GET_TICKS_PER_SECOND, &interval );
directive_failed( sc, "rtems_clock_get -- Ticks Per Second" );
printf(
"Init - rtems_clock_get - Ticks Per Second = %" PRIdrtems_interval "\n",
interval
);
sc = rtems_clock_get( RTEMS_CLOCK_GET_TIME_VALUE, &timev );
directive_failed( sc, "rtems_clock_get -- Time Value" );
printf(
"Init - rtems_clock_get - Time Value = %" PRIdtime_t "\n",
timev.tv_sec
);
puts( "*** END OF TEST LEGACY RTEMS_CLOCK_GET ***" );
rtems_test_exit(0);
}
void fileio_write_file(void)
{
char fname[1024];
char tmp_str[32];
uint32_t file_size = 0;
uint32_t buf_size = 0;
size_t curr_pos,bytes_to_copy;
int fd = -1;
ssize_t n;
rtems_interval start_tick,curr_tick,ticks_per_sec;
char *bufptr = NULL;
boolean failed = FALSE;
static const char write_test_string[] =
"The quick brown fox jumps over the lazy dog\n";
static const char write_block_string[] =
"\n----- end of write buffer ------\n";
printf(" =========================\n");
printf(" WRITE FILE ... \n");
printf(" =========================\n");
fileio_print_free_heap();
/*
* get number of ticks per second
*/
rtems_clock_get(RTEMS_CLOCK_GET_TICKS_PER_SECOND, &ticks_per_sec);
/*
* get path to file to write
*/
if (!failed) {
printf("Enter path/filename ==>");
fflush(stdout);
fgets(fname,sizeof(fname)-1,stdin);
while (fname[strlen(fname)-1] == '\n') {
fname[strlen(fname)-1] = '\0';
}
if (0 == strlen(fname)) {
printf("*** no filename entered, aborted\n");
failed = TRUE;
}
}
/*
* get total file size to write
*/
if (!failed) {
printf("use suffix K for Kbytes, M for Mbytes or no suffix for bytes:\n"
"Enter filesize to write ==>");
fflush(stdout);
fgets(tmp_str,sizeof(tmp_str)-1,stdin);
failed = fileio_str2size(tmp_str,&file_size);
if (failed) {
printf("*** illegal file size, aborted\n");
}
}
/*
* get block size to write
*/
if (!failed) {
printf("use suffix K for Kbytes, M for Mbytes or no suffix for bytes:\n"
"Enter block size to use for write calls ==>");
fflush(stdout);
fgets(tmp_str,sizeof(tmp_str)-1,stdin);
failed = fileio_str2size(tmp_str,&buf_size);
if (failed) {
printf("*** illegal block size, aborted\n");
}
}
/*
* allocate buffer
*/
if (!failed) {
printf("... allocating %lu bytes of buffer for write data\n",
(unsigned long)buf_size);
bufptr = malloc(buf_size+1); /* extra space for terminating NUL char */
if (bufptr == NULL) {
printf("*** malloc failed, aborted\n");
failed = TRUE;
}
}
/*
* fill buffer with test pattern
*/
if (!failed) {
printf("... filling buffer with write data\n");
curr_pos = 0;
/*
* fill buffer with test string
*/
while (curr_pos < buf_size) {
bytes_to_copy = MIN(buf_size-curr_pos,
sizeof(write_test_string)-1);
memcpy(bufptr+curr_pos,write_test_string,bytes_to_copy);
curr_pos += bytes_to_copy;
}
/*
* put "end" mark at end of buffer
*/
bytes_to_copy = sizeof(write_block_string)-1;
if (buf_size >= bytes_to_copy) {
memcpy(bufptr+buf_size-bytes_to_copy,
write_block_string,
bytes_to_copy);
}
}
/*
* create file
*/
if (!failed) {
printf("... creating file \"%s\"\n",fname);
fd = open(fname,O_WRONLY | O_CREAT | O_TRUNC,S_IREAD|S_IWRITE);
if (fd < 0) {
printf("*** file create failed, errno = %d(%s)\n",errno,strerror(errno));
failed = TRUE;
}
}
/*
* write file
*/
if (!failed) {
printf("... writing to file\n");
rtems_clock_get (RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &start_tick);
curr_pos = 0;
do {
bytes_to_copy = buf_size;
do {
n = write(fd,
bufptr + (buf_size-bytes_to_copy),
MIN(bytes_to_copy,file_size-curr_pos));
if (n > 0) {
bytes_to_copy -= n;
curr_pos += n;
}
} while ((bytes_to_copy > 0) && (n > 0));
} while ((file_size > curr_pos) && (n > 0));
rtems_clock_get (RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &curr_tick);
if (n < 0) {
failed = TRUE;
printf("*** file write failed, "
"%lu bytes written, "
"errno = %d(%s)\n",
(unsigned long)curr_pos,errno,strerror(errno));
}
else {
printf("time elapsed for write: %g seconds\n",
((double)curr_tick-start_tick)/ticks_per_sec);
printf("write data rate: %g KBytes/second\n",
(((double)file_size) / 1024.0 /
(((double)curr_tick-start_tick)/ticks_per_sec)));
}
}
if (fd >= 0) {
printf("... closing file\n");
close(fd);
}
if (bufptr != NULL) {
printf("... deallocating buffer\n");
free(bufptr);
bufptr = NULL;
}
printf("\n ******** End of file write\n");
fileio_print_free_heap();
}
rtems_task Tasks_Periodic(
rtems_task_argument argument
)
{
rtems_id rmid;
rtems_id test_rmid;
rtems_status_code status;
bool scenario_done = 0;
int start, stop, now;
rtems_cbs_server_id server_id, tsid;
rtems_cbs_parameters params, tparams;
params.deadline = Periods[ argument ];
params.budget = Execution[ argument ]+1;
if ( argument == 4 ) {
if ( rtems_cbs_create_server( ¶ms, &overrun_handler_task_4, &server_id ))
printf( "ERROR: CREATE SERVER FAILED\n" );
}
else {
if ( rtems_cbs_create_server( ¶ms, NULL, &server_id ) )
printf( "ERROR: CREATE SERVER FAILED\n" );
}
if ( rtems_cbs_attach_thread( server_id, Task_id[ argument ] ) )
printf( "ERROR: ATTACH THREAD FAILED\n" );
if ( rtems_cbs_get_server_id( Task_id[ argument ], &tsid ) )
printf( "ERROR: GET SERVER ID FAILED\n" );
if ( tsid != server_id )
printf( "ERROR: SERVER ID MISMATCH\n" );
if ( rtems_cbs_get_parameters( server_id, &tparams ) )
printf( "ERROR: GET PARAMETERS FAILED\n" );
if ( params.deadline != tparams.deadline ||
params.budget != tparams.budget )
printf( "ERROR: PARAMETERS MISMATCH\n" );
status = rtems_rate_monotonic_create( argument, &rmid );
directive_failed( status, "rtems_rate_monotonic_create" );
put_name( Task_name[ argument ], FALSE );
printf( "- rtems_rate_monotonic_create id = 0x%08" PRIxrtems_id "\n",
rmid );
status = rtems_rate_monotonic_ident( argument, &test_rmid );
directive_failed( status, "rtems_rate_monotonic_ident" );
put_name( Task_name[ argument ], FALSE );
printf( "- rtems_rate_monotonic_ident id = 0x%08" PRIxrtems_id "\n",
test_rmid );
if ( rmid != test_rmid ) {
printf( "RMID's DO NOT MATCH (0x%" PRIxrtems_id " and 0x%"
PRIxrtems_id ")\n", rmid, test_rmid );
rtems_test_exit( 0 );
}
put_name( Task_name[ argument ], FALSE );
printf( "- (0x%08" PRIxrtems_id ") period %" PRIu32 "\n",
rmid, Periods[ argument ] );
status = rtems_task_wake_after( 2 + Phases[argument] );
directive_failed( status, "rtems_task_wake_after" );
while (FOREVER) {
if (rtems_rate_monotonic_period(rmid, Periods[argument])==RTEMS_TIMEOUT)
printf("P%" PRIdPTR " - Deadline miss\n", argument);
rtems_clock_get(RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &start);
printf("P%" PRIdPTR "-S ticks:%d\n", argument, start);
if ( start >= 2*HP_LENGTH ) break; /* stop */
/* Specific scenario for task 4: tries to exceed announced budget,
the task priority has to be pulled down to background. */
if ( !scenario_done && argument == 4 && now >= 200 ) {
Violating_task[ argument ] = 1;
scenario_done = 1;
}
/* Specific scenario for task 3: changes scheduling parameters. */
if ( !scenario_done && argument == 3 && now >= 250 ) {
Periods[ argument ] = Periods[ argument ] * 2;
Execution[ argument ] = Execution[ argument ] * 2;
params.deadline = Periods[ argument ];
params.budget = Execution[ argument ]+1;
if ( rtems_cbs_set_parameters( server_id, ¶ms) )
printf( "ERROR: SET PARAMETERS FAILED\n" );
if ( rtems_cbs_get_parameters( server_id, &tparams ) )
printf( "ERROR: GET PARAMETERS FAILED\n" );
if ( params.deadline != tparams.deadline ||
params.budget != tparams.budget )
printf( "ERROR: PARAMETERS MISMATCH\n" );
scenario_done = 1;
}
/* Specific scenario for task 2: late unblock after being blocked by
itself, the task priority has to be pulled down to background. */
if ( !scenario_done && argument == 2 && now >= 500 ) {
Violating_task[ argument ] = 1;
scenario_done = 1;
}
if (argument == 2 && Violating_task[ argument ])
rtems_task_wake_after( 10 );
/* active computing */
while(FOREVER) {
rtems_clock_get(RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &now);
if ( argument == 4 && !Violating_task[ argument ] &&
(now >= start + Execution[argument]))
break;
if ( argument != 4 && (now >= start + Execution[argument]) )
break;
}
rtems_clock_get(RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &stop);
printf("P%" PRIdPTR "-F ticks:%d\n", argument, stop);
}
/* delete period and SELF */
status = rtems_rate_monotonic_delete( rmid );
if ( status != RTEMS_SUCCESSFUL ) {
printf("rtems_rate_monotonic_delete failed with status of %d.\n",status);
rtems_test_exit( 0 );
}
if ( rtems_cbs_cleanup() )
printf( "ERROR: CBS CLEANUP\n" );
fflush(stdout);
puts( "*** END OF TEST CBS SCHEDULER 3 ***" );
rtems_test_exit( 0 );
}
int
NET_EMBEMB(rtems_,NETDRIVER_PREFIX,_attach)
(struct rtems_bsdnet_ifconfig *config, int attaching)
{
int error = 0;
device_t dev = net_dev_get(config);
struct NET_SOFTC *sc;
struct ifnet *ifp;
#ifndef HAVE_LIBBSPEXT
rtems_irq_connect_data irq_data = {
0,
the_net_isr,
#if ISMINVERSION(4,6,99)
0,
#endif
noop,
noop,
noop1 };
#endif
if ( !dev )
return 1;
if ( !dev->d_softc.NET_SOFTC_BHANDLE_FIELD ) {
#if defined(NETDRIVER_PCI)
device_printf(dev,NETDRIVER" unit not configured; executing setup...");
/* setup should really be performed prior to attaching.
* Wipe the device; setup and re-obtain the device...
*/
memset(dev,0,sizeof(*dev));
error = NET_EMBEMB(rtems_,NETDRIVER_PREFIX,_pci_setup)(-1);
/* re-obtain the device */
dev = net_dev_get(config);
if ( !dev ) {
printk("Unable to re-assign device structure???\n");
return 1;
}
if (error <= 0) {
device_printf(dev,NETDRIVER" FAILED; unable to attach interface, sorry\n");
return 1;
}
device_printf(dev,"success\n");
#else
device_printf(dev,NETDRIVER" unit not configured; use 'rtems_"NETDRIVER"_setup()'\n");
return 1;
#endif
}
if ( !net_driver_ticks_per_sec )
rtems_clock_get( RTEMS_CLOCK_GET_TICKS_PER_SECOND, &net_driver_ticks_per_sec );
sc = device_get_softc( dev );
ifp = &sc->arpcom.ac_if;
#ifdef DEBUG_MODULAR
if (!METHODSPTR) {
device_printf(dev,NETDRIVER": method pointer not set\n");
return -1;
}
#endif
if ( attaching ) {
if ( ifp->if_init ) {
device_printf(dev,NETDRIVER" Driver already attached.\n");
return -1;
}
if ( config->hardware_address ) {
/* use configured MAC address */
memcpy(sc->arpcom.ac_enaddr, config->hardware_address, ETHER_ADDR_LEN);
} else {
#ifdef NET_READ_MAC_ADDR
NET_READ_MAC_ADDR(sc);
#endif
}
if ( METHODSPTR->n_attach(dev) ) {
device_printf(dev,NETDRIVER"_attach() failed\n");
return -1;
}
} else {
if ( !ifp->if_init ) {
device_printf(dev,NETDRIVER" Driver not attached.\n");
return -1;
}
if ( METHODSPTR->n_detach ) {
if ( METHODSPTR->n_detach(dev) ) {
device_printf(dev,NETDRIVER"_detach() failed\n");
return -1;
}
} else {
device_printf(dev,NETDRIVER"_detach() not implemented\n");
return -1;
}
}
if ( !sc->tid )
sc->tid = rtems_bsdnet_newproc(NETDRIVER"d", 4096, net_daemon, sc);
if (attaching) {
#ifdef DEBUG
printf("Installing IRQ # %i\n",sc->irq_no);
#endif
#ifdef HAVE_LIBBSPEXT
if ( bspExtInstallSharedISR(sc->irq_no, the_net_isr, sc, 0) )
#else
/* BSP dependent :-( */
irq_data.name = sc->irq_no;
#if ISMINVERSION(4,6,99)
irq_data.handle = (rtems_irq_hdl_param)sc;
#else
thesc = sc;
#endif
if ( ! BSP_install_rtems_irq_handler( &irq_data ) )
#endif
{
fprintf(stderr,NETDRIVER": unable to install ISR\n");
error = -1;
}
} else {
if ( sc->irq_no ) {
#ifdef DEBUG
printf("Removing IRQ # %i\n",sc->irq_no);
#endif
#ifdef HAVE_LIBBSPEXT
if (bspExtRemoveSharedISR(sc->irq_no, the_net_isr, sc))
#else
/* BSP dependent :-( */
irq_data.name = sc->irq_no;
#if ISMINVERSION(4,6,99)
irq_data.handle = (rtems_irq_hdl_param)sc;
#endif
if ( ! BSP_remove_rtems_irq_handler( &irq_data ) )
#endif
{
fprintf(stderr,NETDRIVER": unable to uninstall ISR\n");
error = -1;
}
}
}
return error;
}
void fileio_read_file(void)
{
char fname[1024];
char tmp_str[32];
uint32_t buf_size = 0;
size_t curr_pos;
int fd = -1;
ssize_t n;
rtems_interval start_tick,curr_tick,ticks_per_sec;
char *bufptr = NULL;
boolean failed = FALSE;
printf(" =========================\n");
printf(" READ FILE ... \n");
printf(" =========================\n");
fileio_print_free_heap();
/*
* get number of ticks per second
*/
rtems_clock_get(RTEMS_CLOCK_GET_TICKS_PER_SECOND, &ticks_per_sec);
/*
* get path to file to read
*/
if (!failed) {
printf("Enter path/filename ==>");
fflush(stdout);
fgets(fname,sizeof(fname)-1,stdin);
while (fname[strlen(fname)-1] == '\n') {
fname[strlen(fname)-1] = '\0';
}
if (0 == strlen(fname)) {
printf("*** no filename entered, aborted\n");
failed = TRUE;
}
}
/*
* get block size to read
*/
if (!failed) {
printf("use suffix K for Kbytes, M for Mbytes or no suffix for bytes:\n"
"Enter block size to use for read calls ==>");
fflush(stdout);
fgets(tmp_str,sizeof(tmp_str)-1,stdin);
failed = fileio_str2size(tmp_str,&buf_size);
if (failed) {
printf("*** illegal block size, aborted\n");
}
}
/*
* allocate buffer
*/
if (!failed) {
printf("... allocating %lu bytes of buffer for write data\n",
(unsigned long)buf_size);
bufptr = malloc(buf_size+1); /* extra space for terminating NUL char */
if (bufptr == NULL) {
printf("*** malloc failed, aborted\n");
failed = TRUE;
}
}
/*
* open file
*/
if (!failed) {
printf("... opening file \"%s\"\n",fname);
fd = open(fname,O_RDONLY);
if (fd < 0) {
printf("*** file open failed, errno = %d(%s)\n",errno,strerror(errno));
failed = TRUE;
}
}
/*
* read file
*/
if (!failed) {
printf("... reading from file\n");
rtems_clock_get (RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &start_tick);
curr_pos = 0;
do {
n = read(fd,
bufptr,
buf_size);
if (n > 0) {
curr_pos += n;
}
} while (n > 0);
rtems_clock_get (RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &curr_tick);
if (n < 0) {
failed = TRUE;
printf("*** file read failed, "
"%lu bytes read, "
"errno = %d(%s)\n",
(unsigned long)curr_pos,errno,strerror(errno));
}
else {
printf("%lu bytes read\n",
(unsigned long)curr_pos);
printf("time elapsed for read: %g seconds\n",
((double)curr_tick-start_tick)/ticks_per_sec);
printf("read data rate: %g KBytes/second\n",
(((double)curr_pos) / 1024.0 /
(((double)curr_tick-start_tick)/ticks_per_sec)));
}
}
if (fd >= 0) {
printf("... closing file\n");
close(fd);
}
if (bufptr != NULL) {
printf("... deallocating buffer\n");
free(bufptr);
bufptr = NULL;
}
printf("\n ******** End of file read\n");
fileio_print_free_heap();
}
static unsigned int
osip_fallback_random_number ()
#endif
{
if (!random_seed_set)
{
unsigned int ticks;
#ifdef __PALMOS__
# if __PALMOS__ < 0x06000000
SysRandom ((Int32) TimGetTicks ());
# else
struct timeval tv;
gettimeofday (&tv, NULL);
srand (tv.tv_usec);
ticks = tv.tv_sec + tv.tv_usec;
# endif
#elif defined(WIN32)
LARGE_INTEGER lCount;
QueryPerformanceCounter (&lCount);
ticks = lCount.LowPart + lCount.HighPart;
#elif defined(_WIN32_WCE)
ticks = GetTickCount ();
#elif defined(__PSOS__)
#elif defined(__rtems__)
rtems_clock_get( RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &ticks);
#elif defined(__VXWORKS_OS__)
struct timespec tp;
clock_gettime (CLOCK_REALTIME, &tp);
ticks = tp.tv_sec + tp.tv_nsec;
#else
struct timeval tv;
int fd;
gettimeofday (&tv, NULL);
ticks = tv.tv_sec + tv.tv_usec;
fd = open ("/dev/urandom", O_RDONLY);
if (fd > 0)
{
unsigned int r;
int i;
for (i = 0; i < 512; i++)
{
read (fd, &r, sizeof (r));
ticks += r;
}
close (fd);
}
#endif
#ifdef HAVE_LRAND48
srand48 (ticks);
#else
srand (ticks);
#endif
random_seed_set = 1;
}
#ifdef HAVE_LRAND48
{
int val = lrand48();
if (val==0)
{
unsigned int ticks;
struct timeval tv;
gettimeofday (&tv, NULL);
ticks = tv.tv_sec + tv.tv_usec;
srand48 (ticks);
return lrand48 ();
}
return val;
}
#else
return rand ();
#endif
}
rtems_task Task_Periodic(
rtems_task_argument argument
)
{
rtems_id rmid;
rtems_status_code status;
time_t approved_budget, exec_time, abs_time, remaining_budget;
int start, stop, now;
rtems_cbs_server_id server_id, tsid;
rtems_cbs_parameters params, tparams;
params.deadline = Period;
params.budget = Execution+1;
/* Taks 1 will be attached to a server, task 2 not. */
if ( argument == 1 ) {
printf( "Periodic task: Create server and Attach thread\n" );
if ( rtems_cbs_create_server( ¶ms, NULL, &server_id ) )
printf( "ERROR: CREATE SERVER FAILED\n" );
if ( rtems_cbs_attach_thread( server_id, Task_id ) )
printf( "ERROR: ATTACH THREAD FAILED\n" );
printf( "Periodic task: ID and Get parameters\n" );
if ( rtems_cbs_get_server_id( Task_id, &tsid ) )
printf( "ERROR: GET SERVER ID FAILED\n" );
if ( tsid != server_id )
printf( "ERROR: SERVER ID MISMATCH\n" );
if ( rtems_cbs_get_parameters( server_id, &tparams ) )
printf( "ERROR: GET PARAMETERS FAILED\n" );
if ( params.deadline != tparams.deadline ||
params.budget != tparams.budget )
printf( "ERROR: PARAMETERS MISMATCH\n" );
printf( "Periodic task: Detach thread and Destroy server\n" );
if ( rtems_cbs_detach_thread( server_id, Task_id ) )
printf( "ERROR: DETACH THREAD FAILED\n" );
if ( rtems_cbs_destroy_server( server_id ) )
printf( "ERROR: DESTROY SERVER FAILED\n" );
if ( rtems_cbs_create_server( ¶ms, NULL, &server_id ) )
printf( "ERROR: CREATE SERVER FAILED\n" );
printf( "Periodic task: Remaining budget and Execution time\n" );
if ( rtems_cbs_get_remaining_budget( server_id, &remaining_budget ) )
printf( "ERROR: GET REMAINING BUDGET FAILED\n" );
if ( remaining_budget != params.budget )
printf( "ERROR: REMAINING BUDGET MISMATCH\n" );
if ( rtems_cbs_get_execution_time( server_id, &exec_time, &abs_time ) )
printf( "ERROR: GET EXECUTION TIME FAILED\n" );
printf( "Periodic task: Set parameters\n" );
if ( rtems_cbs_attach_thread( server_id, Task_id ) )
printf( "ERROR: ATTACH THREAD FAILED\n" );
params.deadline = Period * 2;
params.budget = Execution * 2 +1;
if ( rtems_cbs_set_parameters( server_id, ¶ms ) )
printf( "ERROR: SET PARAMS FAILED\n" );
if ( rtems_cbs_get_parameters( server_id, &tparams ) )
printf( "ERROR: GET PARAMS FAILED\n" );
if ( params.deadline != tparams.deadline ||
params.budget != tparams.budget )
printf( "ERROR: PARAMS MISMATCH\n" );
params.deadline = Period;
params.budget = Execution+1;
if ( rtems_cbs_set_parameters( server_id, ¶ms ) )
printf( "ERROR: SET PARAMS FAILED\n" );
if ( rtems_cbs_get_approved_budget( server_id, &approved_budget ) )
printf( "ERROR: GET APPROVED BUDGET FAILED\n" );
printf( "Periodic task: Approved budget\n" );
if ( approved_budget != params.budget )
printf( "ERROR: APPROVED BUDGET MISMATCH\n" );
}
status = rtems_rate_monotonic_create( argument, &rmid );
directive_failed( status, "rtems_rate_monotonic_create" );
/* Starting periodic behavior of the task */
printf( "Periodic task: Starting periodic behavior\n" );
status = rtems_task_wake_after( 1 + Phase );
directive_failed( status, "rtems_task_wake_after" );
while ( FOREVER ) {
if ( rtems_rate_monotonic_period(rmid, Period) == RTEMS_TIMEOUT )
printf( "P%" PRIdPTR " - Deadline miss\n", argument );
rtems_clock_get( RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &start );
printf( "P%" PRIdPTR "-S ticks:%d\n", argument, start );
if ( start > 4*Period+Phase ) break; /* stop */
/* active computing */
while(FOREVER) {
rtems_clock_get( RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &now );
if ( now >= start + Execution ) break;
if ( rtems_cbs_get_execution_time( server_id, &exec_time, &abs_time ) )
printf( "ERROR: GET EXECUTION TIME FAILED\n" );
if ( rtems_cbs_get_remaining_budget( server_id, &remaining_budget) )
printf( "ERROR: GET REMAINING BUDGET FAILED\n" );
if ( (remaining_budget + exec_time) > (Execution + 1) ) {
printf( "ERROR: REMAINING BUDGET AND EXECUTION TIME MISMATCH\n" );
rtems_test_exit( 0 );
}
}
rtems_clock_get( RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &stop );
printf( "P%" PRIdPTR "-F ticks:%d\n", argument, stop );
}
/* delete period and SELF */
status = rtems_rate_monotonic_delete( rmid );
if ( status != RTEMS_SUCCESSFUL ) {
printf("rtems_rate_monotonic_delete failed with status of %d.\n", status);
rtems_test_exit( 0 );
}
printf( "Periodic task: Deleting self\n" );
status = rtems_task_delete( RTEMS_SELF );
directive_failed( status, "rtems_task_delete of RTEMS_SELF" );
}
