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" ); }