/* open a message queue with the kernel */
int uid_open_queue( const char *q_name, int flags __attribute__((unused)), size_t max_msgs )
{
static rtems_name queue_name;
/*
* For the first device calling this function we would create the queue.
* It is assumed that this call is done at initialization, and no concerns
* regarding multi-threading is taken in consideration here.
*/
if( !open_count )
{
rtems_status_code status;
queue_name = rtems_build_name( q_name[0],
q_name[1],
q_name[2],
q_name[3] );
status = rtems_message_queue_create( queue_name,
max_msgs,
sizeof( struct MW_UID_MESSAGE ),
RTEMS_FIFO | RTEMS_LOCAL,
&queue_id );
if( status != RTEMS_SUCCESSFUL )
{
#ifdef MW_DEBUG_ON
printk( "UID_Queue: error creating queue: %d\n", status );
#endif
return -1;
}
#ifdef MW_DEBUG_ON
printk( "UID_Queue: id=%X\n", queue_id );
#endif
}
open_count++;
return 0;
}
rtems_task Init(rtems_task_argument ignored)
{
rtems_status_code sc;
rtems_id q;
uint32_t flushed;
puts( "\n\n*** TEST 49 ***" );
puts( "Create Message Queue" );
sc = rtems_message_queue_create(
rtems_build_name('m', 's', 'g', ' '),
1,
sizeof(uint32_t),
RTEMS_DEFAULT_ATTRIBUTES,
&q
);
directive_failed( sc, "rtems_message_queue_create" );
puts( "Flush Message Queue using Task Self ID" );
sc = rtems_message_queue_flush( rtems_task_self(), &flushed );
fatal_directive_status( sc, RTEMS_INVALID_ID, "flush" );
puts( "Flush returned INVALID_ID as expected" );
puts( "*** END OF TEST 49 ***" );
rtems_test_exit( 0 );
}
rtems_device_driver usbinput_initialize(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg
)
{
rtems_status_code sc;
rtems_isr_entry dummy;
MM_WRITE(MM_SOFTUSB_CONTROL, SOFTUSB_CONTROL_RESET);
mouse_consume = 0;
keyboard_consume = 0;
midi_consume = 0;
sc = rtems_io_register_name(DEVICE_NAME, major, 0);
RTEMS_CHECK_SC(sc, "create USB input device");
sc = rtems_message_queue_create(
rtems_build_name('U', 'S', 'B', 'I'),
64,
8,
0,
&event_q
);
RTEMS_CHECK_SC(sc, "create USB event queue");
rtems_interrupt_catch(interrupt_handler, MM_IRQ_USB, &dummy);
bsp_interrupt_vector_enable(MM_IRQ_USB);
return RTEMS_SUCCESSFUL;
}
void eval_start(frd_callback callback)
{
rtems_status_code sc;
sc = rtems_message_queue_create(
rtems_build_name('E', 'V', 'A', 'L'),
FRD_COUNT,
sizeof(void *),
0,
&eval_q);
assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_semaphore_create(
rtems_build_name('E', 'V', 'A', 'L'),
0,
RTEMS_SIMPLE_BINARY_SEMAPHORE,
0,
&eval_terminated);
assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_create(rtems_build_name('E', 'V', 'A', 'L'), 10, RTEMS_MINIMUM_STACK_SIZE,
RTEMS_PREEMPT | RTEMS_NO_TIMESLICE | RTEMS_NO_ASR,
0, &eval_task_id);
assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_start(eval_task_id, eval_task, (rtems_task_argument)callback);
assert(sc == RTEMS_SUCCESSFUL);
}
rtems_device_driver ir_initialize(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg
)
{
rtems_status_code sc;
rtems_isr_entry dummy;
sc = rtems_io_register_name(DEVICE_NAME, major, 0);
RTEMS_CHECK_SC(sc, "create IR input device");
sc = rtems_message_queue_create(
rtems_build_name('R', 'C', '5', 'Q'),
64,
2,
0,
&ir_q
);
RTEMS_CHECK_SC(sc, "create IR queue");
rtems_interrupt_catch(interrupt_handler, MM_IRQ_IR, &dummy);
bsp_interrupt_vector_enable(MM_IRQ_IR);
return RTEMS_SUCCESSFUL;
}
/**
* Initial task.
*
* Enables interrupts, runs calibration and starts up new tasks.
*
* Delete itself after completion.
*/
rtems_task Init(rtems_task_argument ignored) {
position_isr.x = 0;
position_isr.y = 0;
rtems_name name;
rtems_status_code status;
name = rtems_build_name('Q','U','E','1');
status = rtems_message_queue_create(name, 1, sizeof(position_t), RTEMS_LOCAL, &msg_queue);
assert( status == RTEMS_SUCCESSFUL );
// setup IRQ handler
status = rtems_interrupt_handler_install(5, NULL, RTEMS_INTERRUPT_UNIQUE, isr, NULL);
assert( status == RTEMS_SUCCESSFUL );
// calibrate
calibrate();
// create semaphore
name = rtems_build_name('S','E','M','1');
status = rtems_semaphore_create(name,1,RTEMS_SIMPLE_BINARY_SEMAPHORE,0,&state_semaphore_id);
assert(status == RTEMS_SUCCESSFUL);
set_status(STATE_READY);
create_and_start_tasks();
// all done. delete itself.
rtems_task_delete(RTEMS_SELF);
}
rtems_status_code
bdbuf_test_create_drv_rx_queue(Objects_Id *id)
{
return rtems_message_queue_create(TEST_DRV_RX_MQUEUE_NAME,
TEST_DRV_RX_MQUEUE_COUNT,
sizeof(bdbuf_test_msg),
RTEMS_DEFAULT_ATTRIBUTES,
id);
}
void Init(
rtems_task_argument argument
)
{
rtems_status_code status;
Print_Warning();
TEST_BEGIN();
status = rtems_message_queue_create(
rtems_build_name( 'M', 'Q', '1', ' ' ),
1,
MESSAGE_SIZE,
RTEMS_DEFAULT_ATTRIBUTES,
&Queue_id
);
directive_failed( status, "rtems_message_queue_create" );
Task_name[0] = rtems_build_name( 'T','A','0','1' );
status = rtems_task_create(
Task_name[0],
30, /* TA01 is low priority task */
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&Task_id[0]
);
directive_failed( status, "rtems_task_create of TA01");
Task_name[1] = rtems_build_name( 'T','A','0','2' );
status = rtems_task_create(
Task_name[1],
28, /* High priority task */
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&Task_id[1]
);
directive_failed( status, "rtems_task_create of TA01" );
benchmark_timer_initialize();
for ( count = 0; count < BENCHMARKS - 1; count++ ) {
/* message send/recieve */
}
tloop_overhead = benchmark_timer_read();
status = rtems_task_start( Task_id[0], Task01, 0 );
directive_failed( status, "rtems_task_start of TA01" );
status = rtems_task_delete( RTEMS_SELF );
directive_failed( status, "rtems_task_delete of RTEMS_SELF" );
}
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 = (int)(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_urgent( Queue_id, Buffer, MESSAGE_SIZE );
}
rtems_task Init(
rtems_task_argument argument
)
{
rtems_id id;
rtems_status_code status;
Print_Warning();
puts( "\n\n*** TIME TEST 22 ***" );
status = rtems_message_queue_create(
rtems_build_name( 'M', 'Q', '1', ' '),
100,
MESSAGE_SIZE,
RTEMS_DEFAULT_ATTRIBUTES,
&Queue_id
);
directive_failed( status, "rtems_message_queue_create" );
status = rtems_task_create(
rtems_build_name( 'L', 'O', 'W', ' ' ),
10,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_NO_PREEMPT,
RTEMS_DEFAULT_ATTRIBUTES,
&id
);
directive_failed( status, "rtems_task_create" );
status = rtems_task_start( id, Low_task, 0 );
directive_failed( status, "rtems_task_start LOW" );
status = rtems_task_create(
1,
11,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&id
);
directive_failed( status, "rtems_task_create RTEMS_PREEMPT" );
status = rtems_task_start( id, Preempt_task, 0 );
directive_failed( status, "rtems_task_start RTEMS_PREEMPT" );
status = rtems_task_delete( RTEMS_SELF );
directive_failed( status, "rtems_task_delete of RTEMS_SELF" );
}
rtems_task Init(
rtems_task_argument argument
)
{
rtems_status_code status;
printf(
"\n\n*** TEST 9 -- NODE %d ***\n",
Multiprocessing_configuration.node
);
Task_name[ 1 ] = rtems_build_name( '1', '1', '1', ' ' );
Task_name[ 2 ] = rtems_build_name( '2', '2', '2', ' ' );
Queue_name[ 1 ] = rtems_build_name( 'M', 'S', 'G', ' ' );
if ( Multiprocessing_configuration.node == 1 ) {
puts( "Creating Message Queue (Global)" );
status = rtems_message_queue_create(
Queue_name[ 1 ],
3,
16,
RTEMS_GLOBAL,
&Queue_id[ 1 ]
);
directive_failed( status, "rtems_message_queue_create" );
}
puts( "Creating Test_task (local)" );
status = rtems_task_create(
Task_name[Multiprocessing_configuration.node],
1,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_TIMESLICE,
RTEMS_DEFAULT_ATTRIBUTES,
&Task_id[ 1 ]
);
directive_failed( status, "rtems_task_create" );
puts( "Starting Test_task (local)" );
status = rtems_task_start( Task_id[ 1 ], Test_task, 0 );
directive_failed( status, "rtems_task_start" );
puts( "Deleting initialization task" );
status = rtems_task_delete( RTEMS_SELF );
directive_failed( status, "rtems_task_delete of RTEMS_SELF" );
}
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;
status = rtems_message_queue_create(
rtems_build_name( 'M', 'Q', '1', ' ' ),
(uint32_t) operation_count,
MESSAGE_SIZE,
RTEMS_DEFAULT_ATTRIBUTES,
&Queue_id
);
directive_failed( status, "rtems_message_queue_create" );
priority = RTEMS_MAXIMUM_PRIORITY - 1u;
if ( OPERATION_COUNT > RTEMS_MAXIMUM_PRIORITY - 2 )
operation_count = RTEMS_MAXIMUM_PRIORITY - 2;
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 = Low_tasks;
status = rtems_task_start( task_id, task_entry, 0 );
directive_failed( status, "rtems_task_start LOOP" );
}
}
epicsShareFunc epicsMessageQueueId epicsShareAPI
epicsMessageQueueCreate(unsigned int capacity, unsigned int maximumMessageSize)
{
rtems_status_code sc;
epicsMessageQueueId id = (epicsMessageQueueId)callocMustSucceed(1, sizeof(*id), "epicsMessageQueueCreate");
rtems_interrupt_level level;
static char c1 = 'a';
static char c2 = 'a';
static char c3 = 'a';
sc = rtems_message_queue_create (rtems_build_name ('Q', c3, c2, c1),
capacity,
maximumMessageSize,
RTEMS_FIFO|RTEMS_LOCAL,
&id->id);
if (sc != RTEMS_SUCCESSFUL) {
errlogPrintf ("Can't create message queue: %s\n", rtems_status_text (sc));
return NULL;
}
id->maxSize = maximumMessageSize;
id->localBuf = NULL;
rtems_interrupt_disable (level);
if (c1 == 'z') {
if (c2 == 'z') {
if (c3 == 'z') {
c3 = 'a';
}
else {
c3++;
}
c2 = 'a';
}
else {
c2++;
}
c1 = 'a';
}
else {
c1++;
}
rtems_interrupt_enable (level);
return id;
}
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 );
}
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);
}
rtems_task Test_task (
rtems_task_argument argument
)
{
benchmark_timer_initialize();
rtems_message_queue_create(
1,
OPERATION_COUNT,
MESSAGE_SIZE,
RTEMS_DEFAULT_ATTRIBUTES,
&Queue_id
);
end_time = benchmark_timer_read();
put_time(
"rtems_message_queue_create: only case",
end_time,
1,
0,
CALLING_OVERHEAD_MESSAGE_QUEUE_CREATE
);
queue_test();
benchmark_timer_initialize();
rtems_message_queue_delete( Queue_id );
end_time = benchmark_timer_read();
put_time(
"rtems_message_queue_delete: only case",
end_time,
1,
0,
CALLING_OVERHEAD_MESSAGE_QUEUE_DELETE
);
TEST_END();
rtems_test_exit( 0 );
}
rtems_task Init(rtems_task_argument argument)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
char region_area [256];
enum resource_type rt = SEMAPHORE;
void *new_region_item = NULL;
size_t i = 0;
puts("\n\n*** TEST 68 ***");
for (i = 0; i < TIMER_COUNT; ++i) {
sc = rtems_timer_create(
rtems_build_name('T', 'I', 'M', '0' + i),
&timer [i]
);
directive_failed(sc, "rtems_timer_create");
}
sc = rtems_timer_initiate_server(
RTEMS_MINIMUM_PRIORITY,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_ATTRIBUTES
);
directive_failed(sc, "rtems_timer_initiate_server");
sc = rtems_semaphore_create(
rtems_build_name('S', 'E', 'M', 'A'),
0,
RTEMS_LOCAL | RTEMS_FIFO | RTEMS_COUNTING_SEMAPHORE,
0,
&semaphore
);
directive_failed(sc, "rtems_semaphore_create");
sc = rtems_semaphore_create(
rtems_build_name('M', 'U', 'T', 'X'),
0,
RTEMS_LOCAL | RTEMS_FIFO | RTEMS_SIMPLE_BINARY_SEMAPHORE,
0,
&mutex
);
directive_failed(sc, "rtems_semaphore_create");
sc = rtems_message_queue_create(
rtems_build_name('M', 'S', 'G', 'Q'),
1,
1,
RTEMS_LOCAL | RTEMS_FIFO,
&message_queue
);
directive_failed(sc, "rtems_message_queue_create");
sc = rtems_region_create(
rtems_build_name('R', 'E', 'G', 'I'),
region_area,
sizeof(region_area),
1,
RTEMS_LOCAL | RTEMS_FIFO,
®ion
);
directive_failed(sc, "rtems_region_create");
do {
region_item = new_region_item;
sc = rtems_region_get_segment(
region, 1, RTEMS_NO_WAIT, 0, &new_region_item);
} while (sc == RTEMS_SUCCESSFUL);
sc = rtems_barrier_create(
rtems_build_name('B', 'A', 'R', 'R'),
RTEMS_LOCAL | RTEMS_FIFO,
2,
&barrier
);
directive_failed(sc, "rtems_barrier_create");
while (rt <= TASK_WAKE_AFTER) {
test_case(rt);
++rt;
}
puts("*** END OF TEST 68 ***");
rtems_test_exit(0);
}
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_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 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)" );
}
rtems_task Init(
rtems_task_argument argument
)
{
rtems_status_code status;
printf(
"\n\n*** TEST 13 -- NODE %d ***\n",
Multiprocessing_configuration.node
);
Task_name[ 1 ] = rtems_build_name( '1', '1', '1', ' ' );
Task_name[ 2 ] = rtems_build_name( '2', '2', '2', ' ' );
Queue_name[ 1 ] = rtems_build_name( 'M', 'S', 'G', ' ' );
Semaphore_name[ 1 ] = rtems_build_name( 'S', 'E', 'M', ' ' );
if ( Multiprocessing_configuration.node == 1 ) {
puts( "Creating Message Queue (Global)" );
status = rtems_message_queue_create(
Queue_name[ 1 ],
3,
16,
RTEMS_GLOBAL,
&Queue_id[ 1 ]
);
directive_failed( status, "rtems_message_queue_create" );
puts( "Creating Semaphore (Global)" );
status = rtems_semaphore_create(
Semaphore_name[ 1 ],
1,
RTEMS_GLOBAL | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&Semaphore_id[ 1 ]
);
directive_failed( status, "rtems_semaphore_create" );
status = rtems_semaphore_obtain(
Semaphore_id[ 1 ],
RTEMS_DEFAULT_OPTIONS,
RTEMS_NO_TIMEOUT
);
directive_failed( status, "rtems_semaphore_obtain" );
}
puts( "Creating Test_task 1 (local)" );
status = rtems_task_create(
Task_name[ 1 ],
1,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_TIMESLICE,
RTEMS_DEFAULT_ATTRIBUTES,
&Task_id[ 1 ]
);
directive_failed( status, "rtems_task_create" );
puts( "Starting Test_task 1 (local)" );
status = rtems_task_start( Task_id[ 1 ], Test_task1, 0 );
directive_failed( status, "rtems_task_start" );
puts( "Creating Test_task 2 (local)" );
status = rtems_task_create(
Task_name[ 2 ],
1,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_TIMESLICE,
RTEMS_DEFAULT_ATTRIBUTES,
&Task_id[ 2 ]
);
directive_failed( status, "rtems_task_create" );
puts( "Starting Test_task 2 (local)" );
status = rtems_task_start( Task_id[ 2 ], Test_task2, 0 );
directive_failed( status, "rtems_task_start" );
if ( Multiprocessing_configuration.node == 1 ) {
status = rtems_task_wake_after( 5 * TICKS_PER_SECOND );
directive_failed( status, "rtems_task_wake_after" );
puts( "*** END OF TEST 13 ***" );
rtems_test_exit( 0 );
}
puts( "Deleting initialization task" );
status = rtems_task_delete( RTEMS_SELF );
directive_failed( status, "rtems_task_delete of RTEMS_SELF" );
}
void
rtems_monitor_server_init(
uint32_t monitor_flags __attribute__((unused))
)
{
#if defined(RTEMS_MULTIPROCESSING)
rtems_status_code status;
if (_System_state_Is_multiprocessing &&
(_Configuration_MP_table->maximum_nodes > 1))
{
uint32_t maximum_nodes = _Configuration_MP_table->maximum_nodes;
/*
* create the msg que our server will listen
* Since we only get msgs from other RTEMS monitors, we just
* need reserve space for 1 msg from each node.
*/
status = rtems_message_queue_create(
RTEMS_MONITOR_QUEUE_NAME,
maximum_nodes,
sizeof(rtems_monitor_server_request_t),
RTEMS_GLOBAL,
&rtems_monitor_server_request_queue_id);
if (status != RTEMS_SUCCESSFUL)
{
rtems_error(status, "could not create monitor server message queue");
goto done;
}
/*
* create the msg que our responses will come on
* Since monitor just does one thing at a time, we only need 1 item
* message queue.
*/
status = rtems_message_queue_create(
RTEMS_MONITOR_RESPONSE_QUEUE_NAME,
1, /* depth */
sizeof(rtems_monitor_server_response_t),
RTEMS_GLOBAL,
&rtems_monitor_server_response_queue_id);
if (status != RTEMS_SUCCESSFUL)
{
rtems_error(status, "could not create monitor response message queue");
goto done;
}
/* need an id for queue of each other server we might talk to */
/* indexed by node, so add 1 to maximum_nodes */
rtems_monitor_server_request_queue_ids =
(rtems_id *) malloc((maximum_nodes + 1) * sizeof(rtems_id));
(void) memset(rtems_monitor_server_request_queue_ids,
0,
(maximum_nodes + 1) * sizeof(rtems_id));
rtems_monitor_server_request_queue_ids[rtems_monitor_node] =
rtems_monitor_server_request_queue_id;
/*
* create the server task
*/
status = rtems_task_create(RTEMS_MONITOR_SERVER_NAME,
1,
0 /* default stack */,
RTEMS_INTERRUPT_LEVEL(0),
RTEMS_DEFAULT_ATTRIBUTES,
&rtems_monitor_server_task_id);
if (status != RTEMS_SUCCESSFUL)
{
rtems_error(status, "could not create monitor server task");
goto done;
}
/*
* Start the server task
*/
status = rtems_task_start(rtems_monitor_server_task_id,
rtems_monitor_server_task,
monitor_flags);
if (status != RTEMS_SUCCESSFUL)
{
rtems_error(status, "could not start monitor server");
goto done;
}
}
done:
#endif
return;
}
/*
* initialization of channel info.
*/
rtems_status_code mscan_channel_initialize(rtems_device_major_number major,
rtems_device_minor_number minor)
{
rtems_status_code status;
struct mscan_channel_info *chan = &chan_info[minor];
/* set registers according to MSCAN channel information */
switch (minor) {
case MSCAN_A:
chan->rx_qname = rtems_build_name('C', 'N', 'A', 'Q');
chan->tx_rb_sname = rtems_build_name('C', 'N', 'A', 'S');
/* register RTEMS device names for MSCAN A */
if ((status =
rtems_io_register_name(MSCAN_A_DEV_NAME, major,
MSCAN_A)) != RTEMS_SUCCESSFUL)
return status;
/* register RTEMS device names for MSCAN 0 */
if ((status =
rtems_io_register_name(MSCAN_0_DEV_NAME, major,
MSCAN_A)) != RTEMS_SUCCESSFUL)
return status;
/* allocate the space for MSCAN A tx ring buffer */
if (((chan->tx_ring_buf.buf_ptr) =
malloc(sizeof (struct can_message) * (NO_OF_MSCAN_TX_BUFF + 1))) !=
NULL) {
chan->tx_ring_buf.head_ptr = chan->tx_ring_buf.tail_ptr =
chan->tx_ring_buf.buf_ptr;
} else {
return RTEMS_UNSATISFIED;
}
break;
case MSCAN_B:
chan->rx_qname = rtems_build_name('C', 'N', 'B', 'Q');
chan->tx_rb_sname = rtems_build_name('C', 'N', 'B', 'S');
/* register RTEMS device names for MSCAN B */
if ((status =
rtems_io_register_name(MSCAN_B_DEV_NAME, major,
MSCAN_B)) != RTEMS_SUCCESSFUL)
return status;
/* register RTEMS device names for MSCAN 1 */
if ((status =
rtems_io_register_name(MSCAN_1_DEV_NAME, major,
MSCAN_B)) != RTEMS_SUCCESSFUL)
return status;
/* allocate the space for MSCAN B tx ring buffer */
if (((chan->tx_ring_buf.buf_ptr) =
malloc(sizeof (struct can_message) * (NO_OF_MSCAN_TX_BUFF + 1))) !=
NULL) {
chan->tx_ring_buf.head_ptr = chan->tx_ring_buf.tail_ptr =
chan->tx_ring_buf.buf_ptr;
} else {
return RTEMS_UNSATISFIED;
}
break;
default:
return RTEMS_UNSATISFIED;
break;
}
/* create RTEMS rx message queue */
status =
rtems_message_queue_create(chan->rx_qname, (uint32_t) NO_OF_MSCAN_RX_BUFF,
(uint32_t)
MSCAN_MESSAGE_SIZE(sizeof (struct can_message)),
(rtems_attribute) RTEMS_LOCAL | RTEMS_FIFO,
(rtems_id *) & (chan->rx_qid));
/* create counting RTEMS tx ring buffer semaphore */
status =
rtems_semaphore_create(chan->tx_rb_sname, (uint32_t) (NO_OF_MSCAN_TX_BUFF),
RTEMS_COUNTING_SEMAPHORE | RTEMS_NO_INHERIT_PRIORITY
| RTEMS_NO_PRIORITY_CEILING | RTEMS_LOCAL,
(rtems_task_priority) 0,
(rtems_id *) & (chan->tx_rb_sid));
/* Set up interrupts */
if (!BSP_install_rtems_irq_handler(&(mpc5200_mscan_irq_data[minor])))
rtems_panic("Can't attach MPC5x00 MSCAN interrupt handler %d\n", minor);
/* basic setup for channel info. struct. */
chan->regs = (mscan *) &(mpc5200.mscan[minor]);
chan->int_rx_err = 0;
chan->id_extended = FALSE;
chan->mode = MSCAN_INITIALIZED_MODE;
chan->tx_buf_no = NO_OF_MSCAN_TX_BUFF;
return status;
}
rtems_task Init(
rtems_task_argument argument
)
{
rtems_status_code status;
printf(
"\n\n*** TEST 10 -- NODE %d ***\n",
Multiprocessing_configuration.node
);
Task_name[ 1 ] = rtems_build_name( 'T', 'A', '1', ' ' );
Task_name[ 2 ] = rtems_build_name( 'T', 'A', '2', ' ' );
Task_name[ 3 ] = rtems_build_name( 'S', 'A', '3', ' ' );
Queue_name[ 1 ] = rtems_build_name( 'M', 'S', 'G', ' ' );
Semaphore_name[ 1 ] = rtems_build_name( 'S', 'E', 'M', ' ' );
if ( Multiprocessing_configuration.node == 1 ) {
puts( "Creating Message Queue (Global)" );
status = rtems_message_queue_create(
Queue_name[ 1 ],
3,
16,
RTEMS_GLOBAL,
&Queue_id[ 1 ]
);
directive_failed( status, "rtems_message_queue_create" );
puts( "Creating Semaphore (Global)" );
status = rtems_semaphore_create(
Semaphore_name[ 1 ],
0,
RTEMS_GLOBAL | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&Semaphore_id[ 1 ]
);
directive_failed( status, "rtems_semaphore_create" );
status = rtems_task_wake_after( 10 * TICKS_PER_SECOND );
directive_failed( status, "rtems_task_wake_after" );
} else {
puts( "Creating Test_task 1 (local)" );
status = rtems_task_create(
Task_name[ 1 ],
1,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_TIMESLICE,
RTEMS_DEFAULT_ATTRIBUTES,
&Task_id[ 1 ]
);
directive_failed( status, "rtems_task_create" );
puts( "Starting Test_task 1 (local)" );
status = rtems_task_start( Task_id[ 1 ], Test_task1, 0 );
directive_failed( status, "rtems_task_start" );
puts( "Creating Test_task 2 (local)" );
status = rtems_task_create(
Task_name[ 2 ],
1,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_TIMESLICE,
RTEMS_DEFAULT_ATTRIBUTES,
&Task_id[ 2 ]
);
directive_failed( status, "rtems_task_create" );
puts( "Starting Test_task 2 (local)" );
status = rtems_task_start( Task_id[ 2 ], Test_task2, 0 );
directive_failed( status, "rtems_task_start" );
puts( "Creating Test_task 3 (local)" );
status = rtems_task_create(
Task_name[ 3 ],
1,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_TIMESLICE,
RTEMS_DEFAULT_ATTRIBUTES,
&Task_id[ 3 ]
);
directive_failed( status, "rtems_task_create" );
puts( "Starting Test_task 3 (local)" );
status = rtems_task_start( Task_id[ 3 ], Test_task2, 0 );
directive_failed( status, "rtems_task_start" );
puts( "Sleeping for 1 seconds ..." );
status = rtems_task_wake_after( TICKS_PER_SECOND );
directive_failed( status, "rtems_task_wake_after" );
puts( "Deleting Test_task2" );
status = rtems_task_delete( Task_id[ 2 ] );
directive_failed( status, "rtems_task_delete of Task 2" );
puts( "Deleting Test_task1" );
status = rtems_task_delete( Task_id[ 1 ] );
directive_failed( status, "rtems_task_delete of Task 1" );
puts( "Restarting Test_task3" );
status = rtems_task_restart( Task_id[ 3 ], 1 );
directive_failed( status, "rtems_task_restart of Task 3" );
}
puts( "*** END OF TEST 10 ***" );
rtems_test_exit( 0 );
}
rtems_task Init(
rtems_task_argument argument
)
{
rtems_status_code status;
rtems_task_priority previous_priority;
printf(
"\n\n*** TEST 14 -- NODE %" PRId32 " ***\n",
Multiprocessing_configuration.node
);
Stop_Test = false;
status = rtems_timer_create(
rtems_build_name('S', 'T', 'O', 'P'),
&timer_id
);
directive_failed( status, "rtems_timer_create" );
status = rtems_timer_fire_after(
timer_id,
MAX_LONG_TEST_DURATION * rtems_clock_get_ticks_per_second(),
Stop_Test_TSR,
NULL
);
directive_failed( status, "rtems_timer_fire_after" );
Task_name[ 1 ] = rtems_build_name( '1', '1', '1', ' ' );
Task_name[ 2 ] = rtems_build_name( '2', '2', '2', ' ' );
Queue_task_name[ 1 ] = rtems_build_name( 'M', 'T', '1', ' ' );
Queue_task_name[ 2 ] = rtems_build_name( 'M', 'T', '2', ' ' );
Partition_task_name[ 1 ] = rtems_build_name( 'P', 'T', '1', ' ' );
Partition_task_name[ 2 ] = rtems_build_name( 'P', 'T', '2', ' ' );
Semaphore_task_name[ 1 ] = rtems_build_name( 'S', 'M', '1', ' ' );
Semaphore_task_name[ 2 ] = rtems_build_name( 'S', 'M', '2', ' ' );
Semaphore_name[ 1 ] = rtems_build_name( 'S', 'E', 'M', ' ' );
Queue_name[ 1 ] = rtems_build_name( 'M', 'S', 'G', ' ' );
Partition_name[ 1 ] = rtems_build_name( 'P', 'A', 'R', ' ' );
Timer_name[ 1 ] = rtems_build_name( 'T', 'M', 'R', ' ' );
if ( Multiprocessing_configuration.node == 1 ) {
puts( "Creating Semaphore (Global)" );
status = rtems_semaphore_create(
Semaphore_name[ 1 ],
1,
RTEMS_GLOBAL,
RTEMS_NO_PRIORITY,
&Semaphore_id[ 1 ]
);
directive_failed( status, "rtems_semaphore_create" );
puts( "Creating Message Queue (Global)" );
status = rtems_message_queue_create(
Queue_name[ 1 ],
1,
16,
RTEMS_GLOBAL,
&Queue_id[ 1 ]
);
directive_failed( status, "rtems_message_queue_create" );
puts( "Creating Partition (Global)" );
status = rtems_partition_create(
Partition_name[ 1 ],
(void *)my_partition,
0x8000,
0x3800,
RTEMS_GLOBAL,
&Partition_id[ 1 ]
);
directive_failed( status, "rtems_partition_create" );
}
puts( "Creating Event task (Global)" );
status = rtems_task_create(
Task_name[ Multiprocessing_configuration.node ],
2,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_TIMESLICE,
RTEMS_GLOBAL,
&Event_task_id[ 1 ]
);
directive_failed( status, "rtems_task_create" );
puts( "Starting Event task (Global)" );
status = rtems_task_start( Event_task_id[ 1 ], Test_task, 0 );
directive_failed( status, "rtems_task_start" );
puts( "Creating Semaphore task (Global)" );
status = rtems_task_create(
Semaphore_task_name[ Multiprocessing_configuration.node ],
2,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_TIMESLICE,
RTEMS_GLOBAL,
&Semaphore_task_id[ 1 ]
);
directive_failed( status, "rtems_task_create" );
puts( "Starting Semaphore task (Global)" );
status = rtems_task_start( Semaphore_task_id[ 1 ], Semaphore_task, 0 );
directive_failed( status, "rtems_task_start" );
puts( "Creating Message Queue task (Global)" );
status = rtems_task_create(
Queue_task_name[ Multiprocessing_configuration.node ],
2,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_TIMESLICE,
RTEMS_GLOBAL,
&Queue_task_id[ 1 ]
);
directive_failed( status, "rtems_task_create" );
/* argument is index into Buffers */
puts( "Starting Message Queue task (Global)" );
status = rtems_task_start( Queue_task_id[ 1 ], Message_queue_task, 1 );
directive_failed( status, "rtems_task_start" );
puts( "Creating Partition task (Global)" );
status = rtems_task_create(
Partition_task_name[ Multiprocessing_configuration.node ],
2,
RTEMS_MINIMUM_STACK_SIZE * 2,
RTEMS_TIMESLICE,
RTEMS_GLOBAL,
&Partition_task_id[ 1 ]
);
directive_failed( status, "rtems_task_create" );
puts( "Starting Partition task (Global)" );
status = rtems_task_start( Partition_task_id[ 1 ], Partition_task, 0 );
directive_failed( status, "rtems_task_start" );
status = rtems_task_set_priority( RTEMS_SELF, 2, &previous_priority );
directive_failed( status, "rtems_task_set_priority" );
status = rtems_task_ident(
RTEMS_SELF,
RTEMS_SEARCH_ALL_NODES,
&Task_id[ 1 ]
);
directive_failed( status, "rtems_task_ident" );
Delayed_events_task( 1 );
}
void
run_bdbuf_tests()
{
rtems_disk_device *disk;
rtems_status_code sc;
dev_t dev = -1;
dev_t test_dev;
unsigned int i;
rtems_device_major_number major;
rtems_driver_address_table testdisk = {
test_disk_initialize,
RTEMS_GENERIC_BLOCK_DEVICE_DRIVER_ENTRIES
};
/* Create a message queue to get events from disk driver. */
sc = rtems_message_queue_create(TEST_TASK_RX_MQUEUE_NAME,
TEST_TASK_RX_MQUEUE_COUNT,
sizeof(bdbuf_test_msg),
RTEMS_DEFAULT_ATTRIBUTES,
&g_test_ctx.test_qid);
if (sc != RTEMS_SUCCESSFUL)
{
printk("Failed to create message queue for test task: %u\n", sc);
return;
}
/* Register a disk device that is used in tests */
sc = rtems_io_register_driver(0, &testdisk, &major);
if (sc != RTEMS_SUCCESSFUL)
{
printk("Failed to register TEST DEVICE: %d\n", sc);
return;
}
test_dev = -1;
while ((disk = rtems_disk_next(dev)) != NULL)
{
printk("DEV: %s [%lu]\n", disk->name, disk->size);
dev = disk->dev;
if (strcmp(disk->name, TEST_DISK_NAME) == 0)
test_dev = dev;
rtems_disk_release(disk);
}
if (test_dev == (dev_t)-1)
{
printf("Failed to find %s disk\n", TEST_DISK_NAME);
return;
}
test_dd = rtems_disk_obtain(test_dev);
if (test_dd == NULL)
{
printf("Failed to obtain %s disk\n", TEST_DISK_NAME);
return;
}
/*
* On initialization test disk device driver registers
* its RX message queue, so we just need to locate it.
*/
sc = rtems_message_queue_ident(TEST_DRV_RX_MQUEUE_NAME,
RTEMS_SEARCH_ALL_NODES,
&g_test_ctx.test_drv_qid);
if (sc != RTEMS_SUCCESSFUL)
{
printf("Failed to find Test Driver Queue: %u\n", sc);
return;
}
for (i = 0; i < ARRAY_NUM(g_test_ctx.test_sync_main); i++)
{
sc = rtems_semaphore_create(rtems_build_name('T', 'S', 'M', '0' + i),
0, TEST_SEM_ATTRIBS, 0,
&g_test_ctx.test_sync_main[i]);
if (sc != RTEMS_SUCCESSFUL)
{
printk("Failed to create sync sem for test task: %u\n", sc);
return;
}
}
for (i = 0; i < ARRAY_NUM(g_test_ctx.test_sync); i++)
{
sc = rtems_semaphore_create(rtems_build_name('T', 'S', 'T', '0' + i),
0, TEST_SEM_ATTRIBS, 0,
&g_test_ctx.test_sync[i]);
if (sc != RTEMS_SUCCESSFUL)
{
printk("Failed to create sync sem for test task #%d: %u\n", i + 1, sc);
return;
}
}
sc = rtems_semaphore_create(rtems_build_name('T', 'S', 'M', 'E'),
0, TEST_SEM_ATTRIBS, 0,
&g_test_ctx.test_end_main);
if (sc != RTEMS_SUCCESSFUL)
{
printk("Failed to create end sync sem for test task: %u\n", sc);
return;
}
for (i = 0; i < ARRAY_NUM(g_test_ctx.test_task); i++)
g_test_ctx.test_task[i] = OBJECTS_ID_NONE;
for (i = 0; i < sizeof(bdbuf_tests) / sizeof(bdbuf_tests[0]); i++)
{
bdbuf_tests[i].main();
}
}
rtems_device_driver ac97_initialize(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg
)
{
rtems_status_code sc;
rtems_isr_entry dummy;
sc = rtems_io_register_name(SND_DEVICE_NAME, major, 0);
RTEMS_CHECK_SC(sc, "create snd device");
sc = rtems_io_register_name(MIXER_DEVICE_NAME, major, 1);
RTEMS_CHECK_SC(sc, "create mixer device");
sc = rtems_semaphore_create(
rtems_build_name('C', 'R', 'W', 'S'),
0,
RTEMS_SIMPLE_BINARY_SEMAPHORE,
0,
&cr_write_sem
);
RTEMS_CHECK_SC(sc, "create AC97 register write semaphore");
sc = rtems_semaphore_create(
rtems_build_name('C', 'R', 'R', 'S'),
0,
RTEMS_SIMPLE_BINARY_SEMAPHORE,
0,
&cr_read_sem
);
RTEMS_CHECK_SC(sc, "create AC97 register read semaphore");
sc = rtems_message_queue_create(
rtems_build_name('P', 'L', 'Y', 'Q'),
PLAY_Q_SIZE*2,
sizeof(void *),
0,
&play_q_done
);
RTEMS_CHECK_SC(sc, "create playback done queue");
sc = rtems_message_queue_create(
rtems_build_name('R', 'E', 'C', 'Q'),
RECORD_Q_SIZE*2,
sizeof(void *),
0,
&record_q_done
);
RTEMS_CHECK_SC(sc, "create record done queue");
rtems_interrupt_catch(crrequest_handler, MM_IRQ_AC97CRREQUEST, &dummy);
rtems_interrupt_catch(crreply_handler, MM_IRQ_AC97CRREPLY, &dummy);
rtems_interrupt_catch(pcmplay_handler, MM_IRQ_AC97DMAR, &dummy);
rtems_interrupt_catch(pcmrecord_handler, MM_IRQ_AC97DMAW, &dummy);
bsp_interrupt_vector_enable(MM_IRQ_AC97CRREQUEST);
bsp_interrupt_vector_enable(MM_IRQ_AC97CRREPLY);
bsp_interrupt_vector_enable(MM_IRQ_AC97DMAR);
bsp_interrupt_vector_enable(MM_IRQ_AC97DMAW);
play_produce = 0;
play_consume = 0;
play_level = 0;
record_produce = 0;
record_consume = 0;
record_level = 0;
return RTEMS_SUCCESSFUL;
}
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 Init(
rtems_task_argument argument
)
{
rtems_status_code status;
puts( "\n\n*** TEST 13 ***" );
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', ' ' );
status = rtems_task_create(
Task_name[ 1 ],
4,
RTEMS_MINIMUM_STACK_SIZE * 2,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&Task_id[ 1 ]
);
directive_failed( status, "rtems_task_create of TA1" );
status = rtems_task_create(
Task_name[ 2 ],
4,
RTEMS_MINIMUM_STACK_SIZE * 2,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&Task_id[ 2 ]
);
directive_failed( status, "rtems_task_create of TA2" );
status = rtems_task_create(
Task_name[ 3 ],
4,
RTEMS_MINIMUM_STACK_SIZE * 2,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&Task_id[ 3 ]
);
directive_failed( status, "rtems_task_create of TA3" );
status = rtems_task_start( Task_id[ 1 ], Task_1, 0 );
directive_failed( status, "rtems_task_start of TA1" );
status = rtems_task_start( Task_id[ 2 ], Task_2, 0 );
directive_failed( status, "rtems_task_start of TA2" );
status = rtems_task_start( Task_id[ 3 ], Task_3, 0 );
directive_failed( status, "rtems_task_start of TA3" );
Queue_name[ 1 ] = rtems_build_name( 'Q', '1', ' ', ' ' );
Queue_name[ 2 ] = rtems_build_name( 'Q', '2', ' ', ' ' );
Queue_name[ 3 ] = rtems_build_name( 'Q', '3', ' ', ' ' );
status = rtems_message_queue_create(
Queue_name[ 1 ],
100,
MESSAGE_SIZE,
RTEMS_DEFAULT_ATTRIBUTES,
&Queue_id[ 1 ]
);
directive_failed( status, "rtems_message_queue_create of Q1" );
status = rtems_message_queue_create(
Queue_name[ 2 ],
10,
MESSAGE_SIZE,
RTEMS_PRIORITY,
&Queue_id[ 2 ]
);
directive_failed( status, "rtems_message_queue_create of Q2" );
status = rtems_message_queue_create(
Queue_name[ 3 ],
100,
MESSAGE_SIZE,
RTEMS_DEFAULT_ATTRIBUTES,
&Queue_id[ 3 ]
);
directive_failed( status, "rtems_message_queue_create of Q3" );
status = rtems_task_delete( RTEMS_SELF );
directive_failed( status, "rtems_task_delete of RTEMS_SELF" );
}
void test_init()
{
int index;
size_t size;
rtems_task_entry task_entry;
rtems_status_code status;
rtems_task_priority priority;
rtems_id task_id;
priority = 2;
if ( OPERATION_COUNT > RTEMS_MAXIMUM_PRIORITY - 2 )
operation_count = RTEMS_MAXIMUM_PRIORITY - 2;
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==0 ) task_entry = High_task;
else if ( index==operation_count-1 ) task_entry = Low_task;
else task_entry = Middle_tasks;
status = rtems_task_start( task_id, task_entry, 0 );
directive_failed( status, "rtems_task_start LOOP" );
}
status = rtems_message_queue_create(
1,
(uint32_t)operation_count,
16,
RTEMS_DEFAULT_ATTRIBUTES,
&Queue_id
);
directive_failed( status, "rtems_message_queue_create" );
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_receive(
Queue_id,
(long (*)[4]) Buffer,
&size,
RTEMS_NO_WAIT,
RTEMS_NO_TIMEOUT
);
end_time = benchmark_timer_read();
put_time(
"rtems_message_queue_receive: not available NO_WAIT",
end_time,
operation_count,
overhead,
CALLING_OVERHEAD_MESSAGE_QUEUE_RECEIVE
);
}