static rtems_isr interrupt_handler(rtems_vector_number n) { unsigned char msg[8]; int i; lm32_interrupt_ack(1 << MM_IRQ_USB); while(mouse_consume != COMLOC_MEVT_PRODUCE) { for(i=0;i<4;i++) msg[i] = COMLOC_MEVT(4*mouse_consume+i); rtems_message_queue_send(event_q, msg, 4); mouse_consume = (mouse_consume + 1) & 0x0f; } while(keyboard_consume != COMLOC_KEVT_PRODUCE) { for(i=0;i<8;i++) msg[i] = COMLOC_KEVT(8*keyboard_consume+i); rtems_message_queue_send(event_q, msg, 8); keyboard_consume = (keyboard_consume + 1) & 0x07; } while(midi_consume != COMLOC_MIDI_PRODUCE) { for(i=0;i<3;i++) msg[i] = COMLOC_MIDI(4*midi_consume+i+1); rtems_message_queue_send(event_q, msg, 3); midi_consume = (midi_consume + 1) & 0x0f; } }
rtems_task High_task( rtems_task_argument argument ) { int index; benchmark_timer_initialize(); for ( index=1 ; index < operation_count ; index++ ) (void) benchmark_timer_empty_function(); overhead = benchmark_timer_read(); benchmark_timer_initialize(); for ( index=1 ; index < operation_count ; index++ ) (void) rtems_message_queue_send( Queue_id, Buffer, MESSAGE_SIZE ); end_time = benchmark_timer_read(); put_time( "rtems_message_queue_send: task readied -- returns to caller", end_time, operation_count - 1, overhead, CALLING_OVERHEAD_MESSAGE_QUEUE_SEND ); puts( "*** END OF TEST 12 ***" ); rtems_test_exit( 0 ); }
/* * add a message to the queue of events. This method cna be used to * simulate hardware events, and it can be very handy during development * a new interface. */ int uid_send_message( struct MW_UID_MESSAGE *m ) { rtems_status_code status; status = rtems_message_queue_send( queue_id, ( void * )m, sizeof( struct MW_UID_MESSAGE ) ); return status == RTEMS_SUCCESSFUL ? 0 : -1; }
static rtems_isr interrupt_handler(rtems_vector_number n) { unsigned short int msg; lm32_interrupt_ack(1 << MM_IRQ_IR); msg = MM_READ(MM_IR_RX); rtems_message_queue_send(ir_q, &msg, 2); }
rtems_task Task01( rtems_task_argument ignored ) { rtems_status_code status; /* Put a message in the queue so recieve overhead can be found. */ (void) rtems_message_queue_send( Queue_id, Buffer, MESSAGE_SIZE ); /* Start up second task, get preempted */ status = rtems_task_start( Task_id[1], Task02, 0 ); directive_failed( status, "rtems_task_start" ); for ( ; count < BENCHMARKS; count++ ) { (void) rtems_message_queue_send( Queue_id, Buffer, MESSAGE_SIZE ); } /* Should never reach here */ rtems_test_assert( false ); }
void eval_stop(void) { void *dummy; dummy = NULL; rtems_message_queue_send(eval_q, &dummy, sizeof(void *)); rtems_semaphore_obtain(eval_terminated, RTEMS_WAIT, RTEMS_NO_TIMEOUT); /* task self-deleted */ rtems_semaphore_delete(eval_terminated); rtems_message_queue_delete(eval_q); }
rtems_task test_init( rtems_task_argument argument ) { int index; rtems_task_entry task_entry; rtems_task_priority priority; rtems_id task_id; rtems_status_code status; /* As each task is started, it preempts this task and * performs a blocking rtems_message_queue_receive. Upon completion of * this loop all created tasks are blocked. */ status = rtems_message_queue_create( rtems_build_name( 'M', 'Q', '1', ' ' ), OPERATION_COUNT, MESSAGE_SIZE, RTEMS_DEFAULT_ATTRIBUTES, &Queue_id ); directive_failed( status, "rtems_message_queue_create" ); priority = RTEMS_MAXIMUM_PRIORITY - 2u; if ( OPERATION_COUNT > RTEMS_MAXIMUM_PRIORITY - 2u ) operation_count = RTEMS_MAXIMUM_PRIORITY - 2u; for( index = 0; index < operation_count ; index++ ) { status = rtems_task_create( rtems_build_name( 'T', 'I', 'M', 'E' ), priority, RTEMS_MINIMUM_STACK_SIZE, RTEMS_DEFAULT_MODES, RTEMS_DEFAULT_ATTRIBUTES, &task_id ); directive_failed( status, "rtems_task_create LOOP" ); priority--; if ( index==operation_count-1 ) task_entry = High_task; else task_entry = Middle_tasks; status = rtems_task_start( task_id, task_entry, 0 ); directive_failed( status, "rtems_task_start LOOP" ); } benchmark_timer_initialize(); (void) rtems_message_queue_send( Queue_id, Buffer, MESSAGE_SIZE ); }
static rtems_isr pcmplay_handler(rtems_vector_number n) { lm32_interrupt_ack(1 << MM_IRQ_AC97DMAR); rtems_message_queue_send(play_q_done, &play_q[play_consume], sizeof(void *)); play_consume = (play_consume + 1) & PLAY_Q_MASK; play_level--; if(play_level > 0) play_start(play_q[play_consume]); else MM_WRITE(MM_AC97_DCTL, 0); }
rtems_task Middle_tasks( rtems_task_argument argument ) { size_t size; (void) rtems_message_queue_receive( Queue_id, (long (*)[4]) Buffer, &size, RTEMS_DEFAULT_OPTIONS, RTEMS_NO_TIMEOUT ); (void) rtems_message_queue_send( Queue_id, (long (*)[4]) Buffer, size ); }
static void release_callback(rtems_id timer_id, void *arg) { rtems_status_code sc = RTEMS_SUCCESSFUL; char buf [1]; size_t size = sizeof(buf); uint32_t released = 0; assert_time(T4); rtems_test_assert( obtain_try && interrupt_happened && !delayed_happened && !interrupt_triggered_happened && !server_triggered_happened ); switch (resource_type) { case SEMAPHORE: sc = rtems_semaphore_release(semaphore); break; case MUTEX: sc = rtems_semaphore_release(mutex); break; case MESSAGE_QUEUE: sc = rtems_message_queue_send(message_queue, buf, size); break; case EVENT: sc = rtems_event_send(_Timer_server->thread->Object.id, RTEMS_EVENT_0); break; case BARRIER: sc = rtems_barrier_release(barrier, &released); break; case TASK_WAKE_AFTER: sc = RTEMS_SUCCESSFUL; break; default: rtems_test_assert(false); break; } directive_failed_with_level(sc, "release", 1); release_happened = true; }
rtems_task Init( rtems_task_argument argument ) { uint32_t count; rtems_id task_id; rtems_status_code status; puts( "\n\n*** LED BLINKER -- message receive server ***" ); LED_INIT(); (void) rtems_message_queue_create( rtems_build_name( 'Q', '1', ' ', ' ' ), 1, sizeof(uint32_t), RTEMS_DEFAULT_ATTRIBUTES, &Queue_id ); (void) rtems_task_create( rtems_build_name( 'T', 'A', '1', ' ' ), 1, RTEMS_MINIMUM_STACK_SIZE, RTEMS_DEFAULT_MODES, RTEMS_DEFAULT_ATTRIBUTES, &task_id ); (void) rtems_task_start( task_id, Test_task, 1 ); for (count=0; ; count++) { /* fprintf( stderr, "send 0x%d\n", count ); */ status = rtems_message_queue_send( Queue_id, &count, sizeof(uint32_t) ); if ( status != RTEMS_SUCCESSFUL ) fputs( "send did not work\n", stderr ); (void) rtems_task_wake_after( rtems_clock_get_ticks_per_second() ); } (void) rtems_task_delete( RTEMS_SELF ); }
static rtems_isr pcmrecord_handler(rtems_vector_number n) { lm32_interrupt_ack(1 << MM_IRQ_AC97DMAW); __asm__ volatile( /* Invalidate Level-1 data cache */ "wcsr DCC, r0\n" "nop\n" ); rtems_message_queue_send(record_q_done, &record_q[record_consume], sizeof(void *)); record_consume = (record_consume + 1) & RECORD_Q_MASK; record_level--; if(record_level > 0) record_start(record_q[record_consume]); else MM_WRITE(MM_AC97_UCTL, 0); }
rtems_task Init( rtems_task_argument ignored ) { rtems_status_code status; rtems_id id; int msg = 1; uint32_t count = 20; puts( "\n\n*** TEST 55 ***" ); puts( "Init - rtems_message_queue_create - OK" ); status = rtems_message_queue_create( rtems_build_name( 'Q', '1', ' ', ' ' ), 2, sizeof(int), RTEMS_DEFAULT_ATTRIBUTES, &id ); directive_failed( status, "rtems_message_queue_create" ); puts( "Init - rtems_message_queue_send - make message pending - OK" ); status = rtems_message_queue_send( id, &msg, sizeof(msg) ); directive_failed( status, "rtems_message_queue_send" ); puts( "Init - rtems_message_queue_broadcast - with message pending - OK" ); status = rtems_message_queue_broadcast( id, &msg, sizeof(msg), &count ); directive_failed( status, "rtems_message_queue_broadcast" ); if ( count != 0 ) { puts( "broadcast with message pending FAILED" ); rtems_test_exit(0); } puts( "Init - rtems_message_queue_delete - OK" ); status = rtems_message_queue_delete( id ); directive_failed( status, "rtems_message_queue_delete" ); puts( "*** END OF TEST 55 ***" ); rtems_test_exit(0); }
/** * interrupt handler */ void isr(void *dummy) { uint32_t input; i386_inport_byte(0x7070, input); //read position encoders uint8_t enc_x = ENC_X_VAL(input); uint8_t enc_y = ENC_Y_VAL(input); position_isr.x -= get_direction(OLD_ENC_X, enc_x); position_isr.y -= get_direction(OLD_ENC_Y, enc_y); rtems_status_code status; uint32_t deleted; status = rtems_message_queue_flush(msg_queue, &deleted); //flush queue - old messages are not relevant from now on assert(status == RTEMS_SUCCESSFUL); status = rtems_message_queue_send(msg_queue, (void*)&position_isr, sizeof(position_t)); //write the last position assert(status == RTEMS_SUCCESSFUL); OLD_ENC_X = enc_x; OLD_ENC_Y = enc_y; }
rtems_task Task_1( rtems_task_argument argument ) { rtems_id qid; uint32_t index; uint32_t count; rtems_status_code status; size_t size; size_t queue_size; unsigned char *cp; status = rtems_message_queue_ident( Queue_name[ 1 ], RTEMS_SEARCH_ALL_NODES, &qid ); printf( "TA1 - rtems_message_queue_ident - qid => %08" PRIxrtems_id "\n", qid ); directive_failed( status, "rtems_message_queue_ident" ); Fill_buffer( "BUFFER 1 TO Q 1", buffer ); puts( "TA1 - rtems_message_queue_send - BUFFER 1 TO Q 1" ); status = rtems_message_queue_send( Queue_id[ 1 ], buffer, MESSAGE_SIZE ); directive_failed( status, "rtems_message_queue_send" ); Fill_buffer( "BUFFER 2 TO Q 1", buffer ); puts( "TA1 - rtems_message_queue_send - BUFFER 2 TO Q 1" ); status = rtems_message_queue_send( Queue_id[ 1 ], buffer, MESSAGE_SIZE ); directive_failed( status, "rtems_message_queue_send" ); puts( "TA1 - rtems_task_wake_after - sleep 5 seconds" ); status = rtems_task_wake_after( 5*rtems_clock_get_ticks_per_second() ); directive_failed( status, "rtems_task_wake_after" ); Fill_buffer( "BUFFER 3 TO Q 1", buffer ); puts( "TA1 - rtems_message_queue_send - BUFFER 3 TO Q 1" ); status = rtems_message_queue_send( Queue_id[ 1 ], buffer, MESSAGE_SIZE ); directive_failed( status, "rtems_message_queue_send" ); puts( "TA1 - rtems_task_wake_after - sleep 5 seconds" ); status = rtems_task_wake_after( 5*rtems_clock_get_ticks_per_second() ); directive_failed( status, "rtems_task_wake_after" ); rtems_test_pause(); Fill_buffer( "BUFFER 1 TO Q 2", buffer ); puts( "TA1 - rtems_message_queue_send - BUFFER 1 TO Q 2" ); status = rtems_message_queue_send( Queue_id[ 2 ], buffer, MESSAGE_SIZE ); directive_failed( status, "rtems_message_queue_send" ); puts_nocr( "TA1 - rtems_message_queue_receive - receive from queue 1 - " ); puts ( "10 second timeout" ); status = rtems_message_queue_receive( Queue_id[ 1 ], buffer, &size, RTEMS_DEFAULT_OPTIONS, 10 * rtems_clock_get_ticks_per_second() ); directive_failed( status, "rtems_message_queue_receive" ); puts_nocr( "TA1 - buffer received: " ); Put_buffer( buffer ); new_line; puts( "TA1 - rtems_task_delete - delete TA2" ); status = rtems_task_delete( Task_id[ 2 ] ); directive_failed( status, "rtems_task_delete" ); Fill_buffer( "BUFFER 1 TO Q 3", buffer ); puts( "TA1 - rtems_message_queue_send - BUFFER 1 TO Q 3" ); status = rtems_message_queue_send( Queue_id[ 3 ], buffer, MESSAGE_SIZE ); directive_failed( status, "rtems_message_queue_send" ); puts( "TA1 - rtems_task_wake_after - sleep 5 seconds" ); status = rtems_task_wake_after( 5*rtems_clock_get_ticks_per_second() ); directive_failed( status, "rtems_task_wake_after" ); rtems_test_pause(); Fill_buffer( "BUFFER 2 TO Q 3", buffer ); puts( "TA1 - rtems_message_queue_send - BUFFER 2 TO Q 3" ); status = rtems_message_queue_send( Queue_id[ 3 ], buffer, MESSAGE_SIZE ); directive_failed( status, "rtems_message_queue_send" ); Fill_buffer( "BUFFER 3 TO Q 3", buffer ); puts( "TA1 - rtems_message_queue_send - BUFFER 3 TO Q 3" ); status = rtems_message_queue_send( Queue_id[ 3 ], buffer, MESSAGE_SIZE ); directive_failed( status, "rtems_message_queue_send" ); Fill_buffer( "BUFFER 4 TO Q 3", buffer ); puts( "TA1 - rtems_message_queue_send - BUFFER 4 TO Q 3" ); status = rtems_message_queue_send( Queue_id[ 3 ], buffer, MESSAGE_SIZE ); directive_failed( status, "rtems_message_queue_send" ); Fill_buffer( "BUFFER 5 TO Q 3", buffer ); puts( "TA1 - rtems_message_queue_urgent - BUFFER 5 TO Q 3" ); status = rtems_message_queue_urgent( Queue_id[ 3 ], buffer, MESSAGE_SIZE ); directive_failed( status, "rtems_message_queue_urgent" ); for ( index = 1 ; index <= 4 ; index++ ) { puts( "TA1 - rtems_message_queue_receive - receive from queue 3 - " "RTEMS_WAIT FOREVER" ); status = rtems_message_queue_receive( Queue_id[ 3 ], buffer, &size, RTEMS_DEFAULT_OPTIONS, RTEMS_NO_TIMEOUT ); directive_failed( status, "rtems_message_queue_receive" ); puts_nocr( "TA1 - buffer received: " ); Put_buffer( buffer ); new_line; } Fill_buffer( "BUFFER 3 TO Q 2", buffer ); puts( "TA1 - rtems_message_queue_urgent - BUFFER 3 TO Q 2" ); status = rtems_message_queue_urgent( Queue_id[ 2 ], buffer, MESSAGE_SIZE ); directive_failed( status, "rtems_message_queue_urgent" ); puts( "TA1 - rtems_message_queue_receive - receive from queue 2 - " "RTEMS_WAIT FOREVER" ); status = rtems_message_queue_receive( Queue_id[ 2 ], buffer, &size, RTEMS_DEFAULT_OPTIONS, RTEMS_NO_TIMEOUT ); directive_failed( status, "rtems_message_queue_receive" ); puts_nocr( "TA1 - buffer received: " ); Put_buffer( buffer ); new_line; rtems_test_pause(); puts( "TA1 - rtems_message_queue_delete - delete queue 1" ); status = rtems_message_queue_delete( Queue_id[ 1 ] ); directive_failed( status, "rtems_message_queue_delete" ); Fill_buffer( "BUFFER 3 TO Q 2", buffer ); puts( "TA1 - rtems_message_queue_urgent - BUFFER 3 TO Q 2" ); status = rtems_message_queue_urgent( Queue_id[ 2 ], buffer, MESSAGE_SIZE ); directive_failed( status, "rtems_message_queue_urgent" ); puts( "TA1 - rtems_message_queue_delete - delete queue 2" ); status = rtems_message_queue_delete( Queue_id[ 2 ] ); directive_failed( status, "rtems_message_queue_delete" ); puts( "TA1 - rtems_message_queue_get_number_pending - check Q 3" ); status = rtems_message_queue_get_number_pending( Queue_id[ 3 ], &count ); directive_failed( status, "rtems_message_queue_get_number_pending" ); printf( "TA1 - %" PRIu32 " messages are pending on Q 3\n", count ); puts( "TA1 - rtems_message_queue_flush - empty Q 3" ); status = rtems_message_queue_flush( Queue_id[ 3 ], &count ); directive_failed( status, "rtems_message_queue_flush" ); printf( "TA1 - %" PRIu32 " messages were flushed from Q 3\n", count ); Fill_buffer( "BUFFER 1 TO Q 3", buffer ); puts( "TA1 - rtems_message_queue_send - BUFFER 1 TO Q 3" ); status = rtems_message_queue_send( Queue_id[ 3 ], buffer, MESSAGE_SIZE ); directive_failed( status, "rtems_message_queue_send" ); Fill_buffer( "BUFFER 2 TO Q 3", buffer ); puts( "TA1 - rtems_message_queue_send - BUFFER 2 TO Q 3" ); status = rtems_message_queue_send( Queue_id[ 3 ], buffer, MESSAGE_SIZE ); directive_failed( status, "rtems_message_queue_send" ); /* this broadcast should have no effect on the queue */ Fill_buffer( "NO BUFFER TO Q1", (long *)buffer ); puts( "TA1 - rtems_message_queue_broadcast - NO BUFFER TO Q1" ); status = rtems_message_queue_broadcast( Queue_id[ 1 ], (long (*)[4])buffer, 16, &count ); printf( "TA1 - number of tasks awakened = %" PRIu32 "\n", count ); puts( "TA1 - rtems_message_queue_get_number_pending - check Q 3" ); status = rtems_message_queue_get_number_pending( Queue_id[ 3 ], &count ); directive_failed( status, "rtems_message_queue_get_number_pending" ); printf( "TA1 - %" PRIu32 " messages are pending on Q 3\n", count ); Fill_buffer( "BUFFER 3 TO Q 3", buffer ); puts( "TA1 - rtems_message_queue_send - BUFFER 3 TO Q 3" ); status = rtems_message_queue_send( Queue_id[ 3 ], buffer, MESSAGE_SIZE ); directive_failed( status, "rtems_message_queue_send" ); puts( "TA1 - rtems_message_queue_flush - Q 3" ); status = rtems_message_queue_flush( Queue_id[ 3 ], &count ); printf( "TA1 - %" PRIu32 " messages were flushed from Q 3\n", count ); puts( "TA1 - rtems_message_queue_send until all message buffers consumed" ); while ( FOREVER ) { status = rtems_message_queue_send( Queue_id[ 3 ], buffer, MESSAGE_SIZE ); if ( status == RTEMS_TOO_MANY ) break; directive_failed( status, "rtems_message_queue_send loop" ); } puts( "TA1 - all message buffers consumed" ); puts( "TA1 - rtems_message_queue_flush - Q 3" ); status = rtems_message_queue_flush( Queue_id[ 3 ], &count ); printf( "TA1 - %" PRIu32 " messages were flushed from Q 3\n", count ); rtems_test_pause(); puts( "TA1 - create message queue of 20 bytes on queue 1" ); status = rtems_message_queue_create( Queue_name[ 1 ], 100, 20, RTEMS_DEFAULT_ATTRIBUTES, &Queue_id[ 1 ] ); directive_failed( status, "rtems_message_queue_create of Q1; 20 bytes each" ); status = rtems_message_queue_send( Queue_id[ 1 ], big_send_buffer, 40 ); fatal_directive_status(status, RTEMS_INVALID_SIZE, "expected RTEMS_INVALID_SIZE" ); puts( "TA1 - rtems_message_queue_delete - delete queue 1" ); status = rtems_message_queue_delete( Queue_id[ 1 ] ); directive_failed( status, "rtems_message_queue_delete" ); rtems_test_pause(); puts( "TA1 - rtems_message_queue_create - variable sizes " ); for (queue_size = 1; queue_size < 1030; queue_size++) { status = rtems_message_queue_create( Queue_name[ 1 ], 2, /* just 2 msgs each */ queue_size, RTEMS_DEFAULT_ATTRIBUTES, &Queue_id[ 1 ] ); if (status != RTEMS_SUCCESSFUL) { printf("TA1 - msq que size: %zu\n", queue_size); directive_failed( status, "rtems_message_queue_create of Q1" ); } status = rtems_message_queue_delete( Queue_id[ 1 ] ); directive_failed( status, "rtems_message_queue_delete" ); } puts( "TA1 - rtems_message_queue_create and send - variable sizes " ); for (queue_size = 1; queue_size < 1030; queue_size++) { status = rtems_message_queue_create( Queue_name[ 1 ], 2, /* just 2 msgs each */ queue_size, RTEMS_DEFAULT_ATTRIBUTES, &Queue_id[ 1 ] ); directive_failed( status, "rtems_message_queue_create of Q1" ); dope_buffer(big_send_buffer, sizeof(big_send_buffer), queue_size); memset(big_receive_buffer, 'Z', sizeof(big_receive_buffer)); /* send a msg too big */ status = rtems_message_queue_send( Queue_id[ 1 ], big_send_buffer, queue_size + 1 ); fatal_directive_status( status, RTEMS_INVALID_SIZE, "rtems_message_queue_send too large" ); /* send a msg that is just right */ status = rtems_message_queue_send( Queue_id[ 1 ], big_send_buffer, queue_size); directive_failed(status, "rtems_message_queue_send exact size"); /* now read and verify the message just sent */ status = rtems_message_queue_receive( Queue_id[ 1 ], big_receive_buffer, &size, RTEMS_DEFAULT_OPTIONS, 1 * rtems_clock_get_ticks_per_second() ); directive_failed(status, "rtems_message_queue_receive exact size"); if (size != queue_size) { puts("TA1 - exact size size match failed"); rtems_test_exit(1); } if (memcmp(big_send_buffer, big_receive_buffer, size) != 0) { puts("TA1 - exact size data match failed"); rtems_test_exit(1); } for (cp = (big_receive_buffer + size); cp < (big_receive_buffer + sizeof(big_receive_buffer)); cp++) if (*cp != 'Z') { puts("TA1 - exact size overrun match failed"); rtems_test_exit(1); } /* all done with this one; delete it */ status = rtems_message_queue_delete( Queue_id[ 1 ] ); directive_failed( status, "rtems_message_queue_delete" ); } puts( "*** END OF TEST 13 ***" ); rtems_test_exit( 0 ); }
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 ); }
void queue_test(void) { uint32_t send_loop_time; uint32_t urgent_loop_time; uint32_t receive_loop_time; uint32_t send_time; uint32_t urgent_time; uint32_t receive_time; uint32_t empty_flush_time; uint32_t flush_time; uint32_t empty_flush_count; uint32_t flush_count; uint32_t index; uint32_t iterations; long buffer[4]; rtems_status_code status; size_t size; send_loop_time = 0; urgent_loop_time = 0; receive_loop_time = 0; send_time = 0; urgent_time = 0; receive_time = 0; empty_flush_time = 0; flush_time = 0; flush_count = 0; empty_flush_count = 0; for ( iterations = 1 ; iterations <= OPERATION_COUNT ; iterations++ ) { benchmark_timer_initialize(); for ( index=1 ; index <= OPERATION_COUNT ; index++ ) (void) benchmark_timer_empty_function(); send_loop_time += benchmark_timer_read(); benchmark_timer_initialize(); for ( index=1 ; index <= OPERATION_COUNT ; index++ ) (void) benchmark_timer_empty_function(); urgent_loop_time += benchmark_timer_read(); benchmark_timer_initialize(); for ( index=1 ; index <= OPERATION_COUNT ; index++ ) (void) benchmark_timer_empty_function(); receive_loop_time += benchmark_timer_read(); benchmark_timer_initialize(); for ( index=1 ; index <= OPERATION_COUNT ; index++ ) (void) rtems_message_queue_send( Queue_id, buffer, MESSAGE_SIZE ); send_time += benchmark_timer_read(); benchmark_timer_initialize(); for ( index=1 ; index <= OPERATION_COUNT ; index++ ) (void) rtems_message_queue_receive( Queue_id, (long (*)[4])buffer, &size, RTEMS_DEFAULT_OPTIONS, RTEMS_NO_TIMEOUT ); receive_time += benchmark_timer_read(); benchmark_timer_initialize(); for ( index=1 ; index <= OPERATION_COUNT ; index++ ) (void) rtems_message_queue_urgent( Queue_id, buffer, MESSAGE_SIZE ); urgent_time += benchmark_timer_read(); benchmark_timer_initialize(); for ( index=1 ; index <= OPERATION_COUNT ; index++ ) (void) rtems_message_queue_receive( Queue_id, (long (*)[4])buffer, &size, RTEMS_DEFAULT_OPTIONS, RTEMS_NO_TIMEOUT ); receive_time += benchmark_timer_read(); benchmark_timer_initialize(); rtems_message_queue_flush( Queue_id, &empty_flush_count ); empty_flush_time += benchmark_timer_read(); /* send one message to flush */ status = rtems_message_queue_send( Queue_id, (long (*)[4])buffer, MESSAGE_SIZE ); directive_failed( status, "rtems_message_queue_send" ); benchmark_timer_initialize(); rtems_message_queue_flush( Queue_id, &flush_count ); flush_time += benchmark_timer_read(); } put_time( "rtems_message_queue_send: no waiting tasks", send_time, OPERATION_COUNT * OPERATION_COUNT, send_loop_time, CALLING_OVERHEAD_MESSAGE_QUEUE_SEND ); put_time( "rtems_message_queue_urgent: no waiting tasks", urgent_time, OPERATION_COUNT * OPERATION_COUNT, urgent_loop_time, CALLING_OVERHEAD_MESSAGE_QUEUE_URGENT ); put_time( "rtems_message_queue_receive: available", receive_time, OPERATION_COUNT * OPERATION_COUNT * 2, receive_loop_time * 2, CALLING_OVERHEAD_MESSAGE_QUEUE_RECEIVE ); put_time( "rtems_message_queue_flush: no messages flushed", empty_flush_time, OPERATION_COUNT, 0, CALLING_OVERHEAD_MESSAGE_QUEUE_FLUSH ); put_time( "rtems_message_queue_flush: messages flushed", flush_time, OPERATION_COUNT, 0, CALLING_OVERHEAD_MESSAGE_QUEUE_FLUSH ); }
/* * MPC5x00 MSCAN interrupt handler */ static void mpc5200_mscan_interrupt_handler(rtems_irq_hdl_param handle) { rtems_status_code status; mscan_handle *mscan_hdl = (mscan_handle *) handle; struct mscan_channel_info *chan = &chan_info[mscan_hdl->mscan_channel]; struct can_message rx_mess, *rx_mess_ptr, *tx_mess_ptr; mscan *m = chan->regs; register uint8_t idx; /* handle tx ring buffer */ /* loop over all 3 tx buffers */ for (idx = TFLG_TXE0; idx <= TFLG_TXE2; idx = idx << 1) { /* check for tx buffer vacation */ if ((m->tflg) & idx) { /* try to get a message */ tx_mess_ptr = get_tx_buffer(chan); /* check for new tx message */ if (tx_mess_ptr != NULL) { /* select the tx buffer */ m->bsel = idx; /* check for toucan interface */ if ((mscan_hdl->toucan_callback) == NULL) { /* set tx id */ m->txidr0 = SET_IDR0(tx_mess_ptr->mess_id); m->txidr1 = SET_IDR1(tx_mess_ptr->mess_id); m->txidr2 = 0; m->txidr3 = 0; } /* fill in tx data if TOUCAN is activ an TOUCAN index have a match with the tx buffer or TOUCAN is disabled */ if (((mscan_hdl->toucan_callback) == NULL) || (((mscan_hdl->toucan_callback) != NULL) && ((tx_mess_ptr->toucan_tx_idx) == idx))) { /* insert dlc into m register */ m->txdlr = (uint8_t) ((tx_mess_ptr->mess_len) & 0x000F); /* skip data copy in case of RTR */ if (!(MSCAN_MESS_ID_HAS_RTR(tx_mess_ptr->mess_id))) { /* copy tx data to MSCAN registers */ switch (m->txdlr) { case 8: m->txdsr7 = tx_mess_ptr->mess_data[7]; case 7: m->txdsr6 = tx_mess_ptr->mess_data[6]; case 6: m->txdsr5 = tx_mess_ptr->mess_data[5]; case 5: m->txdsr4 = tx_mess_ptr->mess_data[4]; case 4: m->txdsr3 = tx_mess_ptr->mess_data[3]; case 3: m->txdsr2 = tx_mess_ptr->mess_data[2]; case 2: m->txdsr1 = tx_mess_ptr->mess_data[1]; case 1: m->txdsr0 = tx_mess_ptr->mess_data[0]; break; default: break; } } /* enable message buffer specific interrupt */ m->tier |= m->bsel; /* start transfer */ m->tflg = m->bsel; /* release counting semaphore of tx ring buffer */ rtems_semaphore_release((rtems_id) (chan->tx_rb_sid)); } else { /* refill the tx ring buffer with the message */ fill_tx_buffer(chan, tx_mess_ptr); } } else { /* reset interrupt enable bit */ m->tier &= ~(idx); } } } /* handle rx interrupts */ /* check for rx interrupt source */ if (m->rier & RIER_RXFIE) { /* can messages received ? */ while (m->rflg & RFLG_RXF) { if (mscan_hdl->toucan_callback == NULL) { /* select temporary rx buffer */ rx_mess_ptr = &rx_mess; } else { /* check the rx fliter-match indicators (16-bit filter mode) */ /* in case of more than one hit, lower hit has priority */ idx = (m->idac) & 0x7; switch (idx) { case 0: case 1: case 2: case 3: rx_mess_ptr = (struct can_message *) &(mpc5200_mscan_rx_cntrl[mscan_hdl->mscan_channel]. can_rx_message[idx]); break; /* this case should never happen */ default: /* reset the rx indication flag */ m->rflg |= RFLG_RXF; return; break; } } /* get rx ID */ rx_mess_ptr->mess_id = GET_IDR0(m->rxidr0) | GET_IDR1(m->rxidr1); /* get rx len */ rx_mess_ptr->mess_len = ((m->rxdlr) & 0x0F); /* get time stamp */ rx_mess_ptr->mess_time_stamp = ((m->rxtimh << 8) | (m->rxtiml)); /* skip data copy in case of RTR */ if (!(MSCAN_MESS_ID_HAS_RTR(rx_mess_ptr->mess_id))) { /* get the data */ switch (rx_mess_ptr->mess_len) { case 8: rx_mess_ptr->mess_data[7] = m->rxdsr7; case 7: rx_mess_ptr->mess_data[6] = m->rxdsr6; case 6: rx_mess_ptr->mess_data[5] = m->rxdsr5; case 5: rx_mess_ptr->mess_data[4] = m->rxdsr4; case 4: rx_mess_ptr->mess_data[3] = m->rxdsr3; case 3: rx_mess_ptr->mess_data[2] = m->rxdsr2; case 2: rx_mess_ptr->mess_data[1] = m->rxdsr1; case 1: rx_mess_ptr->mess_data[0] = m->rxdsr0; case 0: default: break; } } if (mscan_hdl->toucan_callback == NULL) { if ((status = rtems_message_queue_send(chan->rx_qid, (void *) rx_mess_ptr, sizeof (struct can_message))) != RTEMS_SUCCESSFUL) { chan->int_rx_err++; } } else { mscan_hdl->toucan_callback((int16_t) (((m->idac) & 0x7) + 3)); } /* reset the rx indication flag */ m->rflg |= RFLG_RXF; } /* end of while(m->rflg & RFLG_RXF) */ } /* status change detected */ if (m->rflg & RFLG_CSCIF) { m->rflg |= RFLG_CSCIF; if (mscan_hdl->toucan_callback != NULL) { mscan_hdl->toucan_callback((int16_t) (-1)); } } }
void Screen7() { long buffer[ 4 ]; uint32_t count; size_t size; rtems_status_code status; status = rtems_message_queue_broadcast( 100, buffer, MESSAGE_SIZE, &count ); fatal_directive_status( status, RTEMS_INVALID_ID, "rtems_message_queue_broadcast with illegal id" ); puts( "TA1 - rtems_message_queue_broadcast - RTEMS_INVALID_ID" ); /* null ID parameter */ status = rtems_message_queue_create( Queue_name[ 1 ], 3, MESSAGE_SIZE, RTEMS_DEFAULT_ATTRIBUTES, NULL ); fatal_directive_status( status, RTEMS_INVALID_ADDRESS, "rtems_message_queue_create with null param" ); puts( "TA1 - rtems_message_queue_create - NULL Id - RTEMS_INVALID_ADDRESS" ); /* count == 0 */ status = rtems_message_queue_create( Queue_name[ 1 ], 0, MESSAGE_SIZE, RTEMS_DEFAULT_ATTRIBUTES, &Junk_id ); fatal_directive_status( status, RTEMS_INVALID_NUMBER, "rtems_message_queue_create with 0 count" ); puts( "TA1 - rtems_message_queue_create - count = 0 - RTEMS_INVALID_NUMBER" ); /* max size == 0 */ status = rtems_message_queue_create( Queue_name[ 1 ], 3, 0, RTEMS_DEFAULT_ATTRIBUTES, &Junk_id ); fatal_directive_status( status, RTEMS_INVALID_SIZE, "rtems_message_queue_create with 0 msg size" ); puts( "TA1 - rtems_message_queue_create - size = 0 - RTEMS_INVALID_SIZE" ); /* bad name parameter */ status = rtems_message_queue_create( 0, 3, MESSAGE_SIZE, RTEMS_DEFAULT_ATTRIBUTES, &Junk_id ); fatal_directive_status( status, RTEMS_INVALID_NAME, "rtems_message_queue_create with illegal name" ); puts( "TA1 - rtems_message_queue_create - Q 1 - RTEMS_INVALID_NAME" ); /* * The check for an object being global is only made if * multiprocessing is enabled. */ #if defined(RTEMS_MULTIPROCESSING) status = rtems_message_queue_create( Queue_name[ 1 ], 1, MESSAGE_SIZE, RTEMS_GLOBAL, &Junk_id ); fatal_directive_status( status, RTEMS_MP_NOT_CONFIGURED, "rtems_message_queue_create of mp not configured" ); #endif puts( "TA1 - rtems_message_queue_create - Q 1 - RTEMS_MP_NOT_CONFIGURED" ); /* not enough memory for messages */ status = rtems_message_queue_create( Queue_name[ 1 ], INT_MAX, MESSAGE_SIZE, RTEMS_DEFAULT_ATTRIBUTES, &Queue_id[ 1 ] ); fatal_directive_status( status, RTEMS_UNSATISFIED, "rtems_message_queue_create unsatisfied" ); puts( "TA1 - rtems_message_queue_create - Q 2 - RTEMS_UNSATISFIED" ); /* too large a request for messages */ status = rtems_message_queue_create( Queue_name[ 1 ], INT_MAX, INT_MAX, RTEMS_DEFAULT_ATTRIBUTES, &Queue_id[ 1 ] ); fatal_directive_status( status, RTEMS_UNSATISFIED, "rtems_message_queue_create unsatisfied" ); puts( "TA1 - rtems_message_queue_create - Q 2 - RTEMS_UNSATISFIED #2" ); status = rtems_message_queue_create( Queue_name[ 1 ], 2, MESSAGE_SIZE, RTEMS_DEFAULT_ATTRIBUTES, &Queue_id[ 1 ] ); directive_failed( status, "rtems_message_queue_create successful" ); puts( "TA1 - rtems_message_queue_create - Q 1 - 2 DEEP - RTEMS_SUCCESSFUL" ); status = rtems_message_queue_create( Queue_name[ 2 ], 1, MESSAGE_SIZE, RTEMS_DEFAULT_ATTRIBUTES, &Junk_id ); fatal_directive_status( status, RTEMS_TOO_MANY, "rtems_message_queue_create of too many" ); puts( "TA1 - rtems_message_queue_create - Q 2 - RTEMS_TOO_MANY" ); status = rtems_message_queue_delete( 100 ); fatal_directive_status( status, RTEMS_INVALID_ID, "rtems_message_queue_create with illegal id" ); puts( "TA1 - rtems_message_queue_delete - unknown RTEMS_INVALID_ID" ); status = rtems_message_queue_delete( rtems_build_id( 1, 1, 1, 256 ) ); fatal_directive_status( status, RTEMS_INVALID_ID, "rtems_message_queue_delete with local illegal id" ); puts( "TA1 - rtems_message_queue_delete - local RTEMS_INVALID_ID" ); status = rtems_message_queue_ident( 100, RTEMS_SEARCH_ALL_NODES, &Junk_id ); fatal_directive_status( status, RTEMS_INVALID_NAME, "rtems_message_queue_ident with illegal name" ); puts( "TA1 - rtems_message_queue_ident - RTEMS_INVALID_NAME" ); /* number pending - bad Id */ status = rtems_message_queue_get_number_pending( Queue_id[ 1 ], NULL ); fatal_directive_status( status, RTEMS_INVALID_ADDRESS, "rtems_message_queue_get_number_pending with NULL param" ); puts("TA1 - rtems_message_queue_get_number_pending - RTEMS_INVALID_ADDRESS"); /* number pending - bad Id */ status = rtems_message_queue_get_number_pending( 100, &count ); fatal_directive_status( status, RTEMS_INVALID_ID, "rtems_message_queue_get_number_pending with illegal id" ); puts( "TA1 - rtems_message_queue_get_number_pending - RTEMS_INVALID_ID" ); /* flush null param */ status = rtems_message_queue_flush( Queue_id[ 1 ], NULL ); fatal_directive_status( status, RTEMS_INVALID_ADDRESS, "rtems_message_queue_flush with NULL param" ); puts( "TA1 - rtems_message_queue_flush - RTEMS_INVALID_ADDRESS" ); /* flush invalid id */ status = rtems_message_queue_flush( 100, &count ); fatal_directive_status( status, RTEMS_INVALID_ID, "rtems_message_queue_flush with illegal id" ); puts( "TA1 - rtems_message_queue_flush - RTEMS_INVALID_ID" ); status = rtems_message_queue_receive( 100, (long (*)[4]) buffer, &size, RTEMS_DEFAULT_OPTIONS, 0 ); fatal_directive_status( status, RTEMS_INVALID_ID, "rtems_message_queue_receive with illegal id" ); puts( "TA1 - rtems_message_queue_receive - RTEMS_INVALID_ID" ); status = rtems_message_queue_receive( Queue_id[ 1 ], NULL, &size, RTEMS_NO_WAIT, RTEMS_NO_TIMEOUT ); fatal_directive_status( status, RTEMS_INVALID_ADDRESS, "rtems_message_queue_receive NULL buffer" ); puts( "TA1 - rtems_message_queue_receive - Q 1 - " "RTEMS_INVALID_ADDRESS NULL buffer" ); status = rtems_message_queue_receive( Queue_id[ 1 ], (long (*)[4]) buffer, NULL, RTEMS_NO_WAIT, RTEMS_NO_TIMEOUT ); fatal_directive_status( status, RTEMS_INVALID_ADDRESS, "rtems_message_queue_receive NULL size" ); puts( "TA1 - rtems_message_queue_receive - Q 1 - " "RTEMS_INVALID_ADDRESS NULL size" ); status = rtems_message_queue_receive( Queue_id[ 1 ], (long (*)[4]) buffer, &size, RTEMS_NO_WAIT, RTEMS_NO_TIMEOUT ); fatal_directive_status( status, RTEMS_UNSATISFIED, "rtems_message_queue_receive unsatisfied" ); puts( "TA1 - rtems_message_queue_receive - Q 1 - RTEMS_UNSATISFIED" ); puts( "TA1 - rtems_message_queue_receive - Q 1 - timeout in 3 seconds" ); status = rtems_message_queue_receive( Queue_id[ 1 ], (long (*)[4]) buffer, &size, RTEMS_DEFAULT_OPTIONS, 3 * rtems_clock_get_ticks_per_second() ); fatal_directive_status( status, RTEMS_TIMEOUT, "rtems_message_queue_receive 3 second timeout" ); puts( "TA1 - rtems_message_queue_receive - Q 1 - woke up with RTEMS_TIMEOUT" ); /* send NULL message*/ status = rtems_message_queue_send( Queue_id[ 1 ], NULL, MESSAGE_SIZE ); fatal_directive_status( status, RTEMS_INVALID_ADDRESS, "rtems_message_queue_send with NULL buffer" ); puts( "TA1 - rtems_message_queue_send - NULL buffer - RTEMS_INVALID_ADDRESS" ); /* send bad id */ status = rtems_message_queue_send( 100, buffer, MESSAGE_SIZE ); fatal_directive_status( status, RTEMS_INVALID_ID, "rtems_message_queue_send with illegal id" ); puts( "TA1 - rtems_message_queue_send - RTEMS_INVALID_ID" ); status = rtems_message_queue_send( Queue_id[ 1 ], buffer, MESSAGE_SIZE ); directive_failed( status, "rtems_message_queue_send" ); puts( "TA1 - rtems_message_queue_send - BUFFER 1 TO Q 1 - RTEMS_SUCCESSFUL" ); status = rtems_message_queue_send( Queue_id[ 1 ], buffer, MESSAGE_SIZE ); directive_failed( status, "rtems_message_queue_send" ); puts( "TA1 - rtems_message_queue_send - BUFFER 2 TO Q 1 - RTEMS_SUCCESSFUL" ); status = rtems_message_queue_send( Queue_id[ 1 ], buffer, MESSAGE_SIZE ); fatal_directive_status( status, RTEMS_TOO_MANY, "rtems_message_queue_send too many to a limited queue" ); puts( "TA1 - rtems_message_queue_send - BUFFER 3 TO Q 1 - RTEMS_TOO_MANY" ); /* urgent NULL message*/ status = rtems_message_queue_urgent( Queue_id[ 1 ], NULL, MESSAGE_SIZE ); fatal_directive_status( status, RTEMS_INVALID_ADDRESS, "rtems_message_queue_urgent with NULL buffer" ); puts( "TA1 - rtems_message_queue_urgent - NULL buffer - RTEMS_INVALID_ADDRESS" ); /* urgent bad Id */ status = rtems_message_queue_urgent( 100, buffer, MESSAGE_SIZE ); fatal_directive_status( status, RTEMS_INVALID_ID, "rtems_message_queue_urgent with illegal id" ); puts( "TA1 - rtems_message_queue_urgent - RTEMS_INVALID_ID" ); status = rtems_message_queue_broadcast( Queue_id[ 1 ], NULL, MESSAGE_SIZE, &count ); fatal_directive_status( status, RTEMS_INVALID_ADDRESS, "rtems_message_queue_broadcast with NULL count" ); puts( "TA1 - rtems_message_queue_broadcast - NULL buffer - RTEMS_INVALID_ADDRESS" ); status = rtems_message_queue_broadcast( Queue_id[ 1 ], buffer, MESSAGE_SIZE + 1, &count ); fatal_directive_status( status, RTEMS_INVALID_SIZE, "rtems_message_queue_broadcast with too large" ); puts( "TA1 - rtems_message_queue_broadcast - too large - RTEMS_INVALID_SIZE" ); status = rtems_message_queue_broadcast( Queue_id[ 1 ], buffer, MESSAGE_SIZE, NULL ); fatal_directive_status( status, RTEMS_INVALID_ADDRESS, "rtems_message_queue_broadcast with NULL count" ); puts( "TA1 - rtems_message_queue_broadcast - NULL count - RTEMS_INVALID_ADDRESS" ); }
rtems_status_code rtems_monitor_server_request( uint32_t server_node, rtems_monitor_server_request_t *request, rtems_monitor_server_response_t *response ) { rtems_id server_id; rtems_status_code status; size_t size; /* * What is id of monitor on target node? * Look it up if we don't know it yet. */ server_id = rtems_monitor_server_request_queue_ids[server_node]; if (server_id == 0) { status = rtems_message_queue_ident(RTEMS_MONITOR_QUEUE_NAME, server_node, &server_id); if (status != RTEMS_SUCCESSFUL) { rtems_error(status, "ident of remote server failed"); goto done; } rtems_monitor_server_request_queue_ids[server_node] = server_id; } request->return_id = rtems_monitor_server_response_queue_id; status = rtems_message_queue_send(server_id, request, sizeof(*request)); if (status != RTEMS_SUCCESSFUL) { rtems_error(status, "monitor server request send failed"); goto done; } /* * Await response, if requested */ if (response) { status = rtems_message_queue_receive(rtems_monitor_server_response_queue_id, response, &size, RTEMS_WAIT, 100); if (status != RTEMS_SUCCESSFUL) { rtems_error(status, "server did not respond"); /* maybe server task was restarted; look it up again next time */ rtems_monitor_server_request_queue_ids[server_node] = 0; goto done; } if (response->command != RTEMS_MONITOR_SERVER_RESPONSE) { status = RTEMS_INCORRECT_STATE; goto done; } } done: return status; }
void eval_input(struct frame_descriptor *frd) { rtems_message_queue_send(eval_q, &frd, sizeof(void *)); }
void rtems_monitor_server_task( rtems_task_argument monitor_flags __attribute__((unused)) ) { rtems_monitor_server_request_t request; rtems_monitor_server_response_t response; rtems_status_code status; size_t size; for (;;) { status = rtems_message_queue_receive( rtems_monitor_server_request_queue_id, &request, &size, RTEMS_WAIT, (rtems_interval) 0); if (status != RTEMS_SUCCESSFUL) { rtems_error(status, "monitor server msg queue receive error"); goto failed; } if (size != sizeof(request)) { rtems_error(0, "monitor server bad size on receive"); goto failed; } switch (request.command) { case RTEMS_MONITOR_SERVER_CANONICAL: { rtems_monitor_object_type_t object_type; rtems_id id; rtems_id next_id; object_type = (rtems_monitor_object_type_t) request.argument0; id = (rtems_id) request.argument1; next_id = rtems_monitor_object_canonical_get(object_type, id, &response.payload, &size); response.command = RTEMS_MONITOR_SERVER_RESPONSE; response.result0 = next_id; response.result1 = size; #define SERVER_OVERHEAD (offsetof(rtems_monitor_server_response_t, \ payload)) status = rtems_message_queue_send(request.return_id, &response, size + SERVER_OVERHEAD); if (status != RTEMS_SUCCESSFUL) { rtems_error(status, "response send failed"); goto failed; } break; } default: { rtems_error(0, "invalid command to monitor server: %d", request.command); goto failed; } } } failed: rtems_task_delete(RTEMS_SELF); }
void Screen8() { long buffer[ 4 ]; rtems_status_code status; status = rtems_message_queue_delete( Queue_id[ 1 ] ); directive_failed( status, "rtems_message_queue_delete successful" ); puts( "TA1 - rtems_message_queue_delete - Q 1 - RTEMS_SUCCESSFUL" ); status = rtems_message_queue_create( Queue_name[ 1 ], 2, MESSAGE_SIZE, RTEMS_DEFAULT_ATTRIBUTES, &Queue_id[ 1 ] ); directive_failed( status, "rtems_message_queue_create successful" ); puts( "TA1 - rtems_message_queue_create - Q 1 - 2 DEEP - RTEMS_SUCCESSFUL" ); status = rtems_message_queue_send( Queue_id[ 1 ], buffer, MESSAGE_SIZE ); directive_failed( status, "rtems_message_queue_send successful" ); puts( "TA1 - rtems_message_queue_send - BUFFER 1 TO Q 1 - RTEMS_SUCCESSFUL" ); status = rtems_message_queue_send( Queue_id[ 1 ], buffer, MESSAGE_SIZE ); directive_failed( status, "rtems_message_queue_send successful" ); puts( "TA1 - rtems_message_queue_send - BUFFER 2 TO Q 1 - RTEMS_SUCCESSFUL" ); status = rtems_message_queue_send( Queue_id[ 1 ], buffer, MESSAGE_SIZE ); fatal_directive_status( status, RTEMS_TOO_MANY, "rtems_message_queue_send too many to limited queue" ); puts( "TA1 - rtems_message_queue_send - BUFFER 3 TO Q 1 - RTEMS_TOO_MANY" ); status = rtems_message_queue_delete( Queue_id[ 1 ] ); directive_failed( status, "rtems_message_queue_delete successful" ); puts( "TA1 - rtems_message_queue_delete - Q 1 - RTEMS_SUCCESSFUL" ); status = rtems_message_queue_create( Queue_name[ 1 ], 3, MESSAGE_SIZE, RTEMS_DEFAULT_ATTRIBUTES, &Queue_id[ 1 ] ); directive_failed( status, "rtems_message_queue_create successful" ); puts( "TA1 - rtems_message_queue_create - Q 1 - 3 DEEP - RTEMS_SUCCESSFUL" ); status = rtems_message_queue_send( Queue_id[ 1 ], buffer, MESSAGE_SIZE ); directive_failed( status, "rtems_message_queue_send successful" ); puts( "TA1 - rtems_message_queue_send - BUFFER 1 TO Q 1 - RTEMS_SUCCESSFUL" ); status = rtems_message_queue_send( Queue_id[ 1 ], buffer, MESSAGE_SIZE ); directive_failed( status, "rtems_message_queue_send successful" ); puts( "TA1 - rtems_message_queue_send - BUFFER 2 TO Q 1 - RTEMS_SUCCESSFUL" ); status = rtems_message_queue_send( Queue_id[ 1 ], buffer, MESSAGE_SIZE ); directive_failed( status, "rtems_message_queue_send successful" ); puts( "TA1 - rtems_message_queue_send - BUFFER 3 TO Q 1 - RTEMS_SUCCESSFUL" ); status = rtems_message_queue_send( Queue_id[ 1 ], buffer, MESSAGE_SIZE ); fatal_directive_status( status, RTEMS_TOO_MANY, "rtems_message_queue_send too many to limited queue" ); puts( "TA1 - rtems_message_queue_send - BUFFER 4 TO Q 1 - RTEMS_TOO_MANY" ); status = rtems_message_queue_delete( Queue_id[ 1 ] ); directive_failed( status, "rtems_message_queue_delete successful" ); puts( "TA1 - rtems_message_queue_delete - Q 1 - RTEMS_SUCCESSFUL" ); status = rtems_message_queue_create( Queue_name[ 1 ], 3, MESSAGE_SIZE, RTEMS_DEFAULT_ATTRIBUTES, &Queue_id[ 1 ] ); directive_failed( status, "rtems_message_queue_create successful" ); puts( "TA1 - rtems_message_queue_create - Q 1 - 3 DEEP - RTEMS_SUCCESSFUL" ); puts( "TA1 - rtems_task_start - start TA3 - RTEMS_SUCCESSFUL" ); status = rtems_task_start( Task_id[ 3 ], Task_3, 0 ); directive_failed( status, "rtems_task_start of TA3" ); puts( "TA1 - rtems_task_wake_after - yield processor - RTEMS_SUCCESSFUL" ); status = rtems_task_wake_after( RTEMS_YIELD_PROCESSOR ); directive_failed( status, "rtems_task_wake_after (yield)" ); puts( "TA1 - rtems_message_queue_delete - delete Q 1 - RTEMS_SUCCESSFUL" ); status = rtems_message_queue_delete( Queue_id[ 1 ] ); directive_failed( status, "rtems_message_queue_delete successful" ); puts( "TA1 - rtems_task_wake_after - yield processor - RTEMS_SUCCESSFUL" ); status = rtems_task_wake_after( RTEMS_YIELD_PROCESSOR ); directive_failed( status, "rtems_task_wake_after (yield)" ); }
void update_touchscreen (void) { static int graffiti = 0; struct MW_UID_MESSAGE m; int x, y, k, kh, btns = 0; touchPosition pos; char c; /* update keypad & touchscreen */ scanKeys (); pos = touchReadXY (); x = pos.px; y = pos.py; k = keysDown (); kh = keysHeld (); /* check for character recognition */ if ((kh & KEY_L) || (kh & KEY_R)) { graffiti = 1; c = PA_CheckLetter ((kh & KEY_TOUCH ? 1 : 0), x, y); if (c) { /* signal the console driver */ console_push (c); if (kbd_queue_id != 0) { /* send the read character */ m.type = MV_UID_KBD; m.m.kbd.code = c; m.m.kbd.modifiers = 0; m.m.kbd.mode = MV_KEY_MODE_ASCII; rtems_message_queue_send (kbd_queue_id, (void *) &m, sizeof (struct MW_UID_MESSAGE)); } } } else { if (graffiti == 1) { x = old_x; y = old_y; } graffiti = 0; } if (mou_queue_id == 0) return; if (hand == 1) { if (k & KEY_LEFT) { btns = MV_BUTTON_LEFT; } if (k & KEY_RIGHT) { btns = MV_BUTTON_RIGHT; } } else { if (k & KEY_A) { btns = MV_BUTTON_LEFT; } if (k & KEY_B) { btns = MV_BUTTON_RIGHT; } } if (!((kh & KEY_L) || (kh & KEY_R)) && (kh & KEY_TOUCH) && (x != old_x || y != old_y || btns)) { /* send the read position */ m.type = MV_UID_ABS_POS; old_btns = m.m.pos.btns = btns; old_x = m.m.pos.x = x; old_y = m.m.pos.y = y; m.m.pos.z = 0; rtems_message_queue_send (mou_queue_id, (void *) &m, sizeof (struct MW_UID_MESSAGE)); } }
void _Message_queue_MP_Process_packet ( rtems_packet_prefix *the_packet_prefix ) { Message_queue_MP_Packet *the_packet; Thread_Control *the_thread; bool ignored; the_packet = (Message_queue_MP_Packet *) the_packet_prefix; switch ( the_packet->operation ) { case MESSAGE_QUEUE_MP_ANNOUNCE_CREATE: ignored = _Objects_MP_Allocate_and_open( &_Message_queue_Information, the_packet->name, the_packet->Prefix.id, true ); _MPCI_Return_packet( the_packet_prefix ); break; case MESSAGE_QUEUE_MP_ANNOUNCE_DELETE: _Objects_MP_Close( &_Message_queue_Information, the_packet->Prefix.id ); _MPCI_Return_packet( the_packet_prefix ); break; case MESSAGE_QUEUE_MP_EXTRACT_PROXY: the_thread = _Thread_MP_Find_proxy( the_packet->proxy_id ); if (! _Thread_Is_null( the_thread ) ) _Thread_queue_Extract( the_thread ); _MPCI_Return_packet( the_packet_prefix ); break; case MESSAGE_QUEUE_MP_RECEIVE_REQUEST: the_packet->Prefix.return_code = rtems_message_queue_receive( the_packet->Prefix.id, the_packet->Buffer.buffer, &the_packet->size, the_packet->option_set, the_packet->Prefix.timeout ); if ( the_packet->Prefix.return_code != RTEMS_PROXY_BLOCKING ) _Message_queue_MP_Send_response_packet( MESSAGE_QUEUE_MP_RECEIVE_RESPONSE, the_packet->Prefix.id, _Thread_Executing ); break; case MESSAGE_QUEUE_MP_RECEIVE_RESPONSE: the_thread = _MPCI_Process_response( the_packet_prefix ); if (the_packet->Prefix.return_code == RTEMS_SUCCESSFUL) { *(size_t *) the_thread->Wait.return_argument = the_packet->size; _CORE_message_queue_Copy_buffer( the_packet->Buffer.buffer, the_thread->Wait.return_argument_second.mutable_object, the_packet->size ); } _MPCI_Return_packet( the_packet_prefix ); break; case MESSAGE_QUEUE_MP_SEND_REQUEST: the_packet->Prefix.return_code = rtems_message_queue_send( the_packet->Prefix.id, the_packet->Buffer.buffer, the_packet->Buffer.size ); _Message_queue_MP_Send_response_packet( MESSAGE_QUEUE_MP_SEND_RESPONSE, the_packet->Prefix.id, _Thread_Executing ); break; case MESSAGE_QUEUE_MP_SEND_RESPONSE: case MESSAGE_QUEUE_MP_URGENT_RESPONSE: the_thread = _MPCI_Process_response( the_packet_prefix ); _MPCI_Return_packet( the_packet_prefix ); break; case MESSAGE_QUEUE_MP_URGENT_REQUEST: the_packet->Prefix.return_code = rtems_message_queue_urgent( the_packet->Prefix.id, the_packet->Buffer.buffer, the_packet->Buffer.size ); _Message_queue_MP_Send_response_packet( MESSAGE_QUEUE_MP_URGENT_RESPONSE, the_packet->Prefix.id, _Thread_Executing ); break; case MESSAGE_QUEUE_MP_BROADCAST_REQUEST: the_packet->Prefix.return_code = rtems_message_queue_broadcast( the_packet->Prefix.id, the_packet->Buffer.buffer, the_packet->Buffer.size, &the_packet->count ); _Message_queue_MP_Send_response_packet( MESSAGE_QUEUE_MP_BROADCAST_RESPONSE, the_packet->Prefix.id, _Thread_Executing ); break; case MESSAGE_QUEUE_MP_BROADCAST_RESPONSE: case MESSAGE_QUEUE_MP_FLUSH_RESPONSE: case MESSAGE_QUEUE_MP_GET_NUMBER_PENDING_RESPONSE: the_thread = _MPCI_Process_response( the_packet_prefix ); *(uint32_t *) the_thread->Wait.return_argument = the_packet->count; _MPCI_Return_packet( the_packet_prefix ); break; case MESSAGE_QUEUE_MP_FLUSH_REQUEST: the_packet->Prefix.return_code = rtems_message_queue_flush( the_packet->Prefix.id, &the_packet->count ); _Message_queue_MP_Send_response_packet( MESSAGE_QUEUE_MP_FLUSH_RESPONSE, the_packet->Prefix.id, _Thread_Executing ); break; case MESSAGE_QUEUE_MP_GET_NUMBER_PENDING_REQUEST: the_packet->Prefix.return_code = rtems_message_queue_get_number_pending( the_packet->Prefix.id, &the_packet->count ); _Message_queue_MP_Send_response_packet( MESSAGE_QUEUE_MP_GET_NUMBER_PENDING_RESPONSE, the_packet->Prefix.id, _Thread_Executing ); break; } }
rtems_task Message_queue_task( rtems_task_argument index ) { rtems_status_code status; uint32_t count; uint32_t yield_count; uint32_t *buffer_count; uint32_t *overflow_count; size_t size; Msg_buffer[ index ][0] = 0; Msg_buffer[ index ][1] = 0; Msg_buffer[ index ][2] = 0; Msg_buffer[ index ][3] = 0; puts( "Getting ID of msg queue" ); while ( FOREVER ) { status = rtems_message_queue_ident( Queue_name[ 1 ], RTEMS_SEARCH_ALL_NODES, &Queue_id[ 1 ] ); if ( status == RTEMS_SUCCESSFUL ) break; puts( "rtems_message_queue_ident FAILED!!" ); rtems_task_wake_after(2); } if ( Multiprocessing_configuration.node == 1 ) { status = rtems_message_queue_send( Queue_id[ 1 ], (long (*)[4])Msg_buffer[ index ], 16 ); directive_failed( status, "rtems_message_queue_send" ); overflow_count = &Msg_buffer[ index ][0]; buffer_count = &Msg_buffer[ index ][1]; } else { overflow_count = &Msg_buffer[ index ][2]; buffer_count = &Msg_buffer[ index ][3]; } while ( Stop_Test == false ) { yield_count = 100; for ( count=MESSAGE_DOT_COUNT ; Stop_Test == false && count ; count-- ) { status = rtems_message_queue_receive( Queue_id[ 1 ], Msg_buffer[ index ], &size, RTEMS_DEFAULT_OPTIONS, RTEMS_NO_TIMEOUT ); directive_failed( status, "rtems_message_queue_receive" ); if ( *buffer_count == (uint32_t)0xffffffff ) { *buffer_count = 0; *overflow_count += 1; } else *buffer_count += 1; status = rtems_message_queue_send( Queue_id[ 1 ], Msg_buffer[ index ], 16 ); directive_failed( status, "rtems_message_queue_send" ); if (Stop_Test == false) if ( Multiprocessing_configuration.node == 1 && --yield_count == 0 ) { status = rtems_task_wake_after( RTEMS_YIELD_PROCESSOR ); directive_failed( status, "rtems_task_wake_after" ); yield_count = 100; } } put_dot( 'm' ); } Exit_test(); }
rtems_task Test_task( rtems_task_argument argument ) { rtems_status_code status; uint32_t count; size_t size; char receive_buffer[16]; status = rtems_task_wake_after( rtems_clock_get_ticks_per_second() ); directive_failed( status, "rtems_task_wake_after" ); puts( "Getting QID of message queue" ); do { status = rtems_message_queue_ident( Queue_name[ 1 ], RTEMS_SEARCH_ALL_NODES, &Queue_id[ 1 ] ); } while ( !rtems_is_status_successful( status ) ); if ( Multiprocessing_configuration.node == 2 ) { status = rtems_message_queue_delete( Queue_id[ 1 ] ); fatal_directive_status( status, RTEMS_ILLEGAL_ON_REMOTE_OBJECT, "rtems_message_queue_delete" ); puts( "rtems_message_queue_delete correctly returned RTEMS_ILLEGAL_ON_REMOTE_OBJECT" ); Send_messages(); Receive_messages(); puts( "Flushing remote empty queue" ); status = rtems_message_queue_flush( Queue_id[ 1 ], &count ); directive_failed( status, "rtems_message_queue_flush" ); printf( "%" PRIu32 " messages were flushed on the remote queue\n", count ); puts( "Send messages to be flushed from remote queue" ); status = rtems_message_queue_send( Queue_id[ 1 ], buffer1, 16 ); directive_failed( status, "rtems_message_queue_send" ); puts( "Flushing remote queue" ); status = rtems_message_queue_flush( Queue_id[ 1 ], &count ); directive_failed( status, "rtems_message_queue_flush" ); printf( "%" PRIu32 " messages were flushed on the remote queue\n", count ); puts( "Waiting for message queue to be deleted" ); status = rtems_message_queue_receive( Queue_id[ 1 ], receive_buffer, &size, RTEMS_DEFAULT_OPTIONS, RTEMS_NO_TIMEOUT ); fatal_directive_status( status, RTEMS_OBJECT_WAS_DELETED, "rtems_message_queue_receive" ); puts( "\nGlobal message queue deleted" ); } else { /* node == 1 */ Receive_messages(); Send_messages(); puts( "Delaying for 5 seconds" ); status = rtems_task_wake_after( 5*rtems_clock_get_ticks_per_second() ); directive_failed( status, "rtems_task_wake_after" ); puts( "Deleting Message queue" ); status = rtems_message_queue_delete( Queue_id[ 1 ] ); directive_failed( status, "rtems_message_queue_delete" ); } puts( "*** END OF TEST 9 ***" ); rtems_test_exit( 0 ); }
static int test_disk_ioctl(rtems_disk_device *dd, uint32_t req, void *argp) { dev_t dev = rtems_disk_get_device_identifier(dd); rtems_status_code rc; bdbuf_test_msg msg; size_t msg_size; switch (req) { case RTEMS_BLKIO_REQUEST: { rtems_blkdev_request *r = argp; rtems_blkdev_sg_buffer *sg; unsigned int i; printk("DISK_DRV: %s ", r->req == RTEMS_BLKDEV_REQ_READ ? "R" : r->req == RTEMS_BLKDEV_REQ_WRITE ? "W" : "?"); for (i = 0, sg = r->bufs; i < r->bufnum; i++, sg++) { printk("[%d] ", sg->block); } printk("\n"); break; } default: printk("%s() Unexpected request comes %u\n", __FUNCTION__, req); return -1; } memset(&msg, 0, sizeof(msg)); msg.type = BDBUF_TEST_MSG_TYPE_DRIVER_REQ; msg.val.driver_req.dev = dev; msg.val.driver_req.req = req; msg.val.driver_req.argp = argp; rc = rtems_message_queue_send(testq_id, &msg, sizeof(msg)); if (rc != RTEMS_SUCCESSFUL) { printf("Error while sending a message to Test task: %u\n", rc); return -1; } /* Wait for a reply from the test task */ msg_size = sizeof(msg); rc = rtems_message_queue_receive(drvq_id, &msg, &msg_size, RTEMS_WAIT, RTEMS_NO_TIMEOUT); if (rc != RTEMS_SUCCESSFUL) { printf("Error while reading a message from Test task: %u\n", rc); return rc; } if (msg.type != BDBUF_TEST_MSG_TYPE_DRIVER_REPLY) { printf("Unexpected message comes to test disk driver: %d\n", msg.type); return -1; } if (msg.val.driver_reply.ret_val != 0) { errno = msg.val.driver_reply.ret_errno; } else { rtems_blkdev_request *r = (rtems_blkdev_request *)argp; r->req_done(r->done_arg, msg.val.driver_reply.res_status); } return msg.val.driver_reply.ret_val; }