static void test_mrsp_obtain_release(void)
{
rtems_status_code sc;
rtems_id id;
puts("test MrsP obtain and release");
sc = rtems_semaphore_create(
rtems_build_name('M', 'R', 'S', 'P'),
1,
RTEMS_MULTIPROCESSOR_RESOURCE_SHARING
| RTEMS_BINARY_SEMAPHORE,
1,
&id
);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
assert_prio(2);
sc = rtems_semaphore_obtain(id, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
assert_prio(1);
sc = rtems_semaphore_delete(id);
rtems_test_assert(sc == RTEMS_RESOURCE_IN_USE);
sc = rtems_semaphore_release(id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
assert_prio(2);
sc = rtems_semaphore_delete(id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
}
/* i2c_transfer_wait_sema --
* Initiate I2C bus transfer and block on temporary created semaphore
* until this transfer will be finished.
*
* PARAMETERS:
* bus - I2C bus number
* msg - pointer to transfer messages array
* nmsg - number of messages in transfer
*
* RETURNS:
* RTEMS_SUCCESSFUL, if tranfer finished successfully,
* or RTEMS status code if semaphore operations has failed.
*/
static i2c_message_status
i2c_transfer_wait_sema(i2c_bus_number bus, i2c_message *msg, int nmsg)
{
rtems_status_code sc;
rtems_id sema;
sc = rtems_semaphore_create(
rtems_build_name('I', '2', 'C', 'S'),
0,
RTEMS_COUNTING_SEMAPHORE | RTEMS_NO_INHERIT_PRIORITY |
RTEMS_NO_PRIORITY_CEILING | RTEMS_LOCAL,
0,
&sema
);
if (sc != RTEMS_SUCCESSFUL)
return I2C_RESOURCE_NOT_AVAILABLE;
sc = i2c_transfer(bus, nmsg, msg,
i2c_transfer_sema_done_func, &sema);
if (sc != RTEMS_SUCCESSFUL)
{
rtems_semaphore_delete(sema);
return sc;
}
rtems_semaphore_obtain(sema, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
sc = rtems_semaphore_delete(sema);
return sc;
}
rtems_status_code lpc24xx_dma_copy_release(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_status_code rsc = RTEMS_SUCCESSFUL;
sc = rtems_interrupt_handler_remove(
LPC24XX_IRQ_DMA,
lpc24xx_dma_copy_handler,
NULL
);
if (sc != RTEMS_SUCCESSFUL) {
rsc = sc;
}
sc = rtems_semaphore_delete(lpc24xx_dma_sema_table [0]);
if (sc != RTEMS_SUCCESSFUL) {
rsc = sc;
}
sc = rtems_semaphore_delete(lpc24xx_dma_sema_table [1]);
if (sc != RTEMS_SUCCESSFUL) {
rsc = sc;
}
return rsc;
}
rtems_status_code lpc24xx_dma_copy_initialize(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_id id0 = RTEMS_ID_NONE;
rtems_id id1 = RTEMS_ID_NONE;
/* Create semaphore for channel 0 */
sc = rtems_semaphore_create(
rtems_build_name('D', 'M', 'A', '0'),
0,
RTEMS_LOCAL | RTEMS_FIFO | RTEMS_SIMPLE_BINARY_SEMAPHORE,
0,
&id0
);
if (sc != RTEMS_SUCCESSFUL) {
return sc;
}
/* Create semaphore for channel 1 */
sc = rtems_semaphore_create(
rtems_build_name('D', 'M', 'A', '1'),
0,
RTEMS_LOCAL | RTEMS_FIFO | RTEMS_SIMPLE_BINARY_SEMAPHORE,
0,
&id1
);
if (sc != RTEMS_SUCCESSFUL) {
rtems_semaphore_delete(id0);
return sc;
}
/* Install DMA interrupt handler */
sc = rtems_interrupt_handler_install(
LPC24XX_IRQ_DMA,
"DMA copy",
RTEMS_INTERRUPT_UNIQUE,
lpc24xx_dma_copy_handler,
NULL
);
if (sc != RTEMS_SUCCESSFUL) {
rtems_semaphore_delete(id0);
rtems_semaphore_delete(id1);
return sc;
}
/* Initialize global data */
lpc24xx_dma_sema_table [0] = id0;
lpc24xx_dma_sema_table [1] = id1;
return RTEMS_SUCCESSFUL;
}
static void
rtems_termios_destroy_tty (rtems_termios_tty *tty, void *arg, bool last_close)
{
rtems_status_code sc;
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
/*
* call discipline-specific close
*/
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
} else if (last_close) {
/*
* default: just flush output buffer
*/
sc = rtems_semaphore_obtain(tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL) {
rtems_fatal_error_occurred (sc);
}
drainOutput (tty);
rtems_semaphore_release (tty->osem);
}
if (tty->handler.mode == TERMIOS_TASK_DRIVEN) {
/*
* send "terminate" to I/O tasks
*/
sc = rtems_event_send( tty->rxTaskId, TERMIOS_RX_TERMINATE_EVENT );
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
sc = rtems_event_send( tty->txTaskId, TERMIOS_TX_TERMINATE_EVENT );
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
}
if (last_close && tty->handler.last_close)
(*tty->handler.last_close)(tty, arg);
if (tty->device_node != NULL)
tty->device_node->tty = NULL;
rtems_semaphore_delete (tty->isem);
rtems_semaphore_delete (tty->osem);
rtems_semaphore_delete (tty->rawOutBuf.Semaphore);
if ((tty->handler.poll_read == NULL) ||
(tty->handler.mode == TERMIOS_TASK_DRIVEN))
rtems_semaphore_delete (tty->rawInBuf.Semaphore);
rtems_interrupt_lock_destroy (&tty->interrupt_lock);
free (tty->rawInBuf.theBuf);
free (tty->rawOutBuf.theBuf);
free (tty->cbuf);
free (tty);
}
/*
* ioctl handler to be passed to the block device handler
*/
static int sparse_disk_ioctl( rtems_disk_device *dd, uint32_t req, void *argp )
{
rtems_status_code sc;
rtems_sparse_disk *sd = rtems_disk_get_driver_data( dd );
if ( RTEMS_BLKIO_REQUEST == req ) {
rtems_blkdev_request *r = argp;
switch ( r->req ) {
case RTEMS_BLKDEV_REQ_READ:
case RTEMS_BLKDEV_REQ_WRITE:
return sparse_disk_read_write( sd, r, r->req == RTEMS_BLKDEV_REQ_READ );
default:
break;
}
} else if ( RTEMS_BLKIO_DELETED == req ) {
sc = rtems_semaphore_delete( sd->mutex );
if ( RTEMS_SUCCESSFUL != sc )
rtems_fatal_error_occurred( 0xdeadbeef );
sd->mutex = RTEMS_ID_NONE;
if ( NULL != sd->delete_handler )
( *sd->delete_handler )( sd );
return 0;
} else {
return rtems_blkdev_ioctl( dd, req, argp );
}
errno = EINVAL;
return -1;
}
static void test_create_initially_locked_prio_inherit_sema(void)
{
rtems_status_code sc;
rtems_id id;
rtems_task_priority prio_a;
rtems_task_priority prio_b;
rtems_task_priority prio_ceiling = 0;
sc = rtems_task_set_priority(RTEMS_SELF, RTEMS_CURRENT_PRIORITY, &prio_a);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
rtems_test_assert(prio_a != prio_ceiling);
sc = rtems_semaphore_create(
rtems_build_name( 'S', 'E', 'M', 'A' ),
0,
RTEMS_BINARY_SEMAPHORE | RTEMS_PRIORITY | RTEMS_INHERIT_PRIORITY,
prio_ceiling,
&id
);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_set_priority(RTEMS_SELF, RTEMS_CURRENT_PRIORITY, &prio_b);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
rtems_test_assert(prio_a == prio_b);
sc = rtems_semaphore_release(id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_semaphore_delete(id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
}
void
rtems_stdio_redirect_close(rtems_stdio_redirect* sr)
{
if (rtems_stdio_redirect_lock(sr))
{
sr->state &= ~RTEMS_STDIO_REDIRECT_RUNNING;
close(sr->pipe[0]);
rtems_stdio_redirect_unlock(sr);
while (sr->state & RTEMS_STDIO_REDIRECT_FINISHED)
{
usleep(250UL * 1000000UL);
}
rtems_stdio_redirect_lock(sr);
dup2(sr->fd, sr->fd_dup);
free(sr->buffer);
free(sr->input);
rtems_stdio_redirect_unlock(sr);
rtems_semaphore_delete(sr->lock);
free(sr);
}
}
rtems_status_code
rtems_disk_io_done(void)
{
rtems_device_major_number major = 0;
rtems_device_minor_number minor = 0;
for (major = 0; major < disktab_size; ++major) {
rtems_disk_device_table *dtab = disktab + major;
for (minor = 0; minor < dtab->size; ++minor) {
rtems_disk_device *dd = dtab->minor [minor];
if (dd != NULL) {
free_disk_device(dd);
}
}
free(dtab->minor);
}
free(disktab);
rtems_semaphore_delete(diskdevs_mutex);
diskdevs_mutex = RTEMS_ID_NONE;
disktab = NULL;
disktab_size = 0;
return RTEMS_SUCCESSFUL;
}
void
closelog(void)
{
if (LogFd >= 0) {
close (LogFd);
LogFd = -1;
rtems_semaphore_delete (LogSemaphore);
}
}
void delete_semaphore(void)
{
rtems_status_code status;
SemaphoreCount--;
printf( "Deleting semaphore id=0x%08x\n",
(unsigned int) Semaphores[SemaphoreCount] );
status = rtems_semaphore_delete( Semaphores[SemaphoreCount] );
directive_failed( status, "semaphore delete" );
}
/* Called with rtems_pipe_semaphore held. */
static inline void pipe_free(
pipe_control_t *pipe
)
{
rtems_barrier_delete(pipe->readBarrier);
rtems_barrier_delete(pipe->writeBarrier);
rtems_semaphore_delete(pipe->Semaphore);
free(pipe->Buffer);
free(pipe);
}
void
epicsEventDestroy(epicsEventId id)
{
rtems_id sid = (rtems_id)id;
rtems_status_code sc;
sc = rtems_semaphore_delete (sid);
if (sc != RTEMS_SUCCESSFUL)
errlogPrintf ("Can't destroy semaphore: %s\n", rtems_status_text (sc));
}
static int
rtems_tftpfs_shutdown (rtems_filesystem_mount_table_entry_t* mt_entry)
{
tftpfs_info_t *fs = tftpfs_info_mount_table (mt_entry);
int s;
for (s = 0; s < fs->nStreams; s++)
releaseStream (fs, s);
rtems_semaphore_delete (fs->tftp_mutex);
free (fs);
return 0;
}
/*PAGE
*
* task_pool_done
*
* Cleanup task pool.
*
* Input parameters:
* count - number of entries in task pool to cleanup
*
* Output parameters:
* NONE
*
*/
static void
task_pool_done(int count)
{
int i;
for(i = 0; i < count; ++i)
rtems_task_delete(task_pool.info[i].tid);
if(task_pool.info)
free(task_pool.info);
if(task_pool.queue)
free(task_pool.queue);
if(task_pool.mutex != (rtems_id)-1)
rtems_semaphore_delete(task_pool.mutex);
if(task_pool.sem != (rtems_id)-1)
rtems_semaphore_delete(task_pool.sem);
task_pool.info = 0;
task_pool.queue = 0;
task_pool.count = 0;
task_pool.sem = -1;
task_pool.mutex = -1;
}
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);
}
int rtems_gxx_mutex_destroy (__gthread_mutex_t *mutex)
{
rtems_status_code status;
#ifdef DEBUG_GXX_WRAPPERS
printk( "gxx_wrappers: destroy mutex=%X\n", *mutex );
#endif
status = rtems_semaphore_delete(*(rtems_id *)mutex);
if ( status == RTEMS_SUCCESSFUL )
return 0;
return -1;
}
static bool
rtems_rap_data_init (void)
{
/*
* Lock the RAP. We only create a lock if a call is made. First we test if a
* lock is present. If one is present we lock it. If not the libio lock is
* locked and we then test the lock again. If not present we create the lock
* then release libio lock.
*/
if (!rap_.lock)
{
rtems_libio_lock ();
if (!rap_.lock)
{
rtems_status_code sc;
rtems_id lock;
/*
* Create the RAP lock.
*/
sc = rtems_semaphore_create (rtems_build_name ('R', 'A', 'P', '_'),
1, RTEMS_MUTEX_ATTRIBS,
RTEMS_NO_PRIORITY, &lock);
if (sc != RTEMS_SUCCESSFUL)
return false;
sc = rtems_semaphore_obtain (lock, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
{
rtems_semaphore_delete (lock);
return false;
}
rap_.lock = lock;
/*
* Initialise the objects list and create any required services.
*/
rtems_chain_initialize_empty (&rap_.apps);
}
rtems_libio_unlock ();
rtems_rap_unlock ();
}
return true;
}
int
rtems_rfs_mutex_destroy (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc;
sc = rtems_semaphore_delete (*mutex);
if (sc != RTEMS_SUCCESSFUL)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
printf ("rtems-rfs: mutex: close failed: %s\n",
rtems_status_text (sc));
return EIO;
}
#endif
return 0;
}
static void test_mrsp_timeout_and_not_owner_of_resource(void)
{
rtems_status_code sc;
rtems_id id;
rtems_id task_id;
test_mrsp_context ctx;
puts("test MrsP timeout and not owner of resource");
sc = rtems_semaphore_create(
rtems_build_name('M', 'R', 'S', 'P'),
1,
RTEMS_MULTIPROCESSOR_RESOURCE_SHARING
| RTEMS_BINARY_SEMAPHORE,
1,
&id
);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_semaphore_obtain(id, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_create(
rtems_build_name('M', 'R', 'S', 'P'),
1,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&task_id
);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
ctx.semaphore_id = id;
ctx.task_id = rtems_task_self();
sc = rtems_task_start(task_id, test_mrsp_task, (rtems_task_argument) &ctx);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_event_transient_receive(RTEMS_WAIT, RTEMS_NO_TIMEOUT);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_semaphore_release(id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_semaphore_delete(id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
}
static rtems_status_code bsp_interrupt_lock(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (_System_state_Is_up(_System_state_Get())) {
if (bsp_interrupt_mutex == RTEMS_ID_NONE) {
rtems_id mutex = RTEMS_ID_NONE;
rtems_interrupt_level level;
/* Create a mutex */
sc = rtems_semaphore_create (
rtems_build_name('I', 'N', 'T', 'R'),
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
0,
&mutex
);
if (sc != RTEMS_SUCCESSFUL) {
return sc;
}
/* Assign the mutex */
rtems_interrupt_disable(level);
if (bsp_interrupt_mutex == RTEMS_ID_NONE) {
/* Nobody else assigned the mutex in the meantime */
bsp_interrupt_mutex = mutex;
rtems_interrupt_enable(level);
} else {
/* Somebody else won */
rtems_interrupt_enable(level);
sc = rtems_semaphore_delete(mutex);
if (sc != RTEMS_SUCCESSFUL) {
return sc;
}
}
}
return rtems_semaphore_obtain(
bsp_interrupt_mutex,
RTEMS_WAIT,
RTEMS_NO_TIMEOUT
);
} else {
return RTEMS_SUCCESSFUL;
}
}
static void test_mrsp_set_priority(void)
{
rtems_status_code sc;
rtems_id id;
rtems_id scheduler_id;
rtems_task_priority prio;
puts("test MrsP set priority");
sc = rtems_task_get_scheduler(RTEMS_SELF, &scheduler_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_semaphore_create(
rtems_build_name('M', 'R', 'S', 'P'),
1,
RTEMS_MULTIPROCESSOR_RESOURCE_SHARING
| RTEMS_BINARY_SEMAPHORE,
1,
&id
);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
prio = RTEMS_CURRENT_PRIORITY;
sc = rtems_semaphore_set_priority(id, scheduler_id, prio, &prio);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
rtems_test_assert(prio == 1);
prio = 1;
sc = rtems_semaphore_set_priority(id, scheduler_id, prio, &prio);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
rtems_test_assert(prio == 1);
prio = 2;
sc = rtems_semaphore_set_priority(id, scheduler_id, prio, &prio);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
rtems_test_assert(prio == 1);
prio = RTEMS_CURRENT_PRIORITY;
sc = rtems_semaphore_set_priority(id, scheduler_id, prio, &prio);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
rtems_test_assert(prio == 2);
sc = rtems_semaphore_delete(id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
}
static void test_mrsp_set_priority_errors(void)
{
rtems_status_code sc;
rtems_id id;
rtems_id scheduler_id;
rtems_task_priority prio;
puts("test MrsP set priority errors");
sc = rtems_task_get_scheduler(RTEMS_SELF, &scheduler_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_semaphore_create(
rtems_build_name('C', 'O', 'N', 'T'),
0,
RTEMS_COUNTING_SEMAPHORE,
0,
&id
);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
prio = 1;
sc = rtems_semaphore_set_priority(RTEMS_ID_NONE, scheduler_id, prio, &prio);
rtems_test_assert(sc == RTEMS_INVALID_ID);
prio = 1;
sc = rtems_semaphore_set_priority(id, RTEMS_ID_NONE, prio, &prio);
rtems_test_assert(sc == RTEMS_INVALID_ID);
prio = 0xffffffff;
sc = rtems_semaphore_set_priority(id, scheduler_id, prio, &prio);
rtems_test_assert(sc == RTEMS_INVALID_PRIORITY);
prio = 1;
sc = rtems_semaphore_set_priority(id, scheduler_id, prio, NULL);
rtems_test_assert(sc == RTEMS_INVALID_ADDRESS);
prio = 1;
sc = rtems_semaphore_set_priority(id, scheduler_id, prio, &prio);
rtems_test_assert(sc == RTEMS_NOT_DEFINED);
sc = rtems_semaphore_delete(id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
}
rtems_status_code
rtems_disk_io_initialize(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_device_major_number size = DISKTAB_INITIAL_SIZE;
if (disktab_size > 0) {
return RTEMS_SUCCESSFUL;
}
disktab = calloc(size, sizeof(rtems_disk_device_table));
if (disktab == NULL) {
return RTEMS_NO_MEMORY;
}
diskdevs_protected = false;
sc = rtems_semaphore_create(
rtems_build_name('D', 'D', 'E', 'V'),
1,
RTEMS_FIFO | RTEMS_BINARY_SEMAPHORE | RTEMS_NO_INHERIT_PRIORITY
| RTEMS_NO_PRIORITY_CEILING | RTEMS_LOCAL,
0,
&diskdevs_mutex
);
if (sc != RTEMS_SUCCESSFUL) {
free(disktab);
return RTEMS_NO_MEMORY;
}
sc = rtems_bdbuf_init();
if (sc != RTEMS_SUCCESSFUL) {
rtems_semaphore_delete(diskdevs_mutex);
free(disktab);
return RTEMS_UNSATISFIED;
}
disktab_size = size;
return RTEMS_SUCCESSFUL;
}
static void rtems_jffs2_free_fs_info(rtems_jffs2_fs_info *fs_info, bool do_mount_fs_was_successful)
{
struct super_block *sb = &fs_info->sb;
struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
if (do_mount_fs_was_successful) {
jffs2_free_ino_caches(c);
jffs2_free_raw_node_refs(c);
free(c->blocks);
}
if (sb->s_mutex != 0) {
rtems_status_code sc = rtems_semaphore_delete(sb->s_mutex);
assert(sc == RTEMS_SUCCESSFUL);
}
rtems_jffs2_flash_control_destroy(fs_info->sb.s_flash_control);
rtems_jffs2_compressor_control_destroy(fs_info->sb.s_compressor_control);
free(fs_info);
}
static void sticky_task(rtems_task_argument arg)
{
rtems_status_code sc;
rtems_id mtx_id;
(void) arg;
rtems_test_assert(rtems_get_current_processor() == 0);
sc = rtems_semaphore_create(
rtems_build_name(' ', 'M', 'T', 'X'),
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_MULTIPROCESSOR_RESOURCE_SHARING,
2,
&mtx_id
);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_semaphore_obtain(mtx_id, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
ready = true;
sc = rtems_event_transient_receive(RTEMS_WAIT, RTEMS_NO_TIMEOUT);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_semaphore_release(mtx_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_semaphore_delete(mtx_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_event_transient_send(main_task_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
while (1) {
/* Do nothing */
}
}
static void do_test(
rtems_attribute attr,
bool extract /* TRUE if extract, not release */
)
{
rtems_status_code status;
rtems_task_argument i;
Variant = ( ( attr & RTEMS_PRIORITY ) != 0 ? PRIORITY : FIFO );
Obtain_counter = 0;
status = rtems_semaphore_create(
rtems_build_name( 'S', 'E', 'M', '0' ), /* name = SEM0 */
0, /* locked */
RTEMS_BINARY_SEMAPHORE | attr, /* mutex w/desired discipline */
0, /* IGNORED */
&Semaphore
);
directive_failed( status, "rtems_semaphore_create" );
for (i = 0 ; i < MAX_TASKS ; i++ ) {
Task_name[ i ] = rtems_build_name(
'T',
'A',
'0' + (char)(i/10),
'0' + (char)(i%10)
);
status = rtems_task_create(
Task_name[ i ],
Priorities[ i ],
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&Task_id[ i ]
);
directive_failed( status, "rtems_task_create" );
status = rtems_task_start( Task_id[ i ], Locker_task, i );
directive_failed( status, "rtems_task_start" );
}
if ( extract ) {
for (i = 0 ; i< MAX_TASKS ; i++ ) {
status = rtems_task_delete( Task_id[ i ] );
directive_failed( status, "rtems_task_delete" );
}
}
/* do the initial release */
status = rtems_semaphore_release( Semaphore );
directive_failed( status, "rtems_semaphore_release" );
if ( !extract ) {
status = rtems_event_transient_receive( RTEMS_WAIT, RTEMS_NO_TIMEOUT );
directive_failed( status, "rtems_event_transient_receive" );
}
/* now delete the semaphore since no one is waiting and it is unlocked */
status = rtems_semaphore_delete( Semaphore );
directive_failed( status, "rtems_semaphore_delete" );
}
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 );
}
static void test(void)
{
rtems_status_code sc;
rtems_id task_id;
rtems_id scheduler_id;
rtems_id scheduler_a_id;
rtems_id scheduler_b_id;
rtems_id scheduler_c_id;
rtems_task_priority prio;
cpu_set_t cpuset;
cpu_set_t first_cpu;
cpu_set_t second_cpu;
cpu_set_t all_cpus;
cpu_set_t online_cpus;
uint32_t cpu_count;
rtems_test_assert(rtems_get_current_processor() == 0);
cpu_count = rtems_get_processor_count();
main_task_id = rtems_task_self();
CPU_ZERO(&first_cpu);
CPU_SET(0, &first_cpu);
CPU_ZERO(&second_cpu);
CPU_SET(1, &second_cpu);
CPU_FILL(&all_cpus);
CPU_ZERO(&online_cpus);
CPU_SET(0, &online_cpus);
if (cpu_count > 1) {
CPU_SET(1, &online_cpus);
}
sc = rtems_scheduler_ident(SCHED_A, &scheduler_a_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
if (cpu_count > 1) {
sc = rtems_scheduler_ident(SCHED_B, &scheduler_b_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
rtems_test_assert(scheduler_a_id != scheduler_b_id);
}
sc = rtems_scheduler_ident(SCHED_C, &scheduler_c_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_semaphore_create(
rtems_build_name('C', 'M', 'T', 'X'),
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_PRIORITY | RTEMS_PRIORITY_CEILING,
1,
&cmtx_id
);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_semaphore_create(
rtems_build_name('I', 'M', 'T', 'X'),
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_PRIORITY | RTEMS_INHERIT_PRIORITY,
1,
&imtx_id
);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
prio = 2;
sc = rtems_semaphore_set_priority(cmtx_id, scheduler_a_id, prio, &prio);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
rtems_test_assert(prio == 1);
if (cpu_count > 1) {
prio = 1;
sc = rtems_semaphore_set_priority(cmtx_id, scheduler_b_id, prio, &prio);
rtems_test_assert(sc == RTEMS_NOT_DEFINED);
rtems_test_assert(prio == 2);
}
CPU_ZERO(&cpuset);
sc = rtems_scheduler_get_processor_set(
scheduler_a_id,
sizeof(cpuset),
&cpuset
);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
rtems_test_assert(CPU_EQUAL(&cpuset, &first_cpu));
if (cpu_count > 1) {
CPU_ZERO(&cpuset);
sc = rtems_scheduler_get_processor_set(
scheduler_b_id,
sizeof(cpuset),
&cpuset
);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
rtems_test_assert(CPU_EQUAL(&cpuset, &second_cpu));
}
sc = rtems_task_create(
rtems_build_name('T', 'A', 'S', 'K'),
1,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&task_id
);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_get_scheduler(task_id, &scheduler_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
rtems_test_assert(scheduler_id == scheduler_a_id);
CPU_ZERO(&cpuset);
sc = rtems_task_get_affinity(task_id, sizeof(cpuset), &cpuset);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
rtems_test_assert(CPU_EQUAL(&cpuset, &online_cpus));
rtems_test_assert(sched_get_priority_min(SCHED_RR) == 1);
rtems_test_assert(sched_get_priority_max(SCHED_RR) == 254);
sc = rtems_task_set_scheduler(task_id, scheduler_c_id, 1);
rtems_test_assert(sc == RTEMS_UNSATISFIED);
sc = rtems_task_set_scheduler(task_id, scheduler_c_id + 1, 1);
rtems_test_assert(sc == RTEMS_INVALID_ID);
if (cpu_count > 1) {
sc = rtems_task_set_scheduler(task_id, scheduler_b_id, 1);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_get_scheduler(task_id, &scheduler_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
rtems_test_assert(scheduler_id == scheduler_b_id);
CPU_ZERO(&cpuset);
sc = rtems_task_get_affinity(task_id, sizeof(cpuset), &cpuset);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
rtems_test_assert(CPU_EQUAL(&cpuset, &online_cpus));
sc = rtems_task_set_affinity(task_id, sizeof(all_cpus), &all_cpus);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_set_affinity(task_id, sizeof(first_cpu), &first_cpu);
rtems_test_assert(sc == RTEMS_INVALID_NUMBER);
sc = rtems_task_get_scheduler(task_id, &scheduler_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
rtems_test_assert(scheduler_id == scheduler_b_id);
sc = rtems_task_set_affinity(task_id, sizeof(online_cpus), &online_cpus);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_set_affinity(task_id, sizeof(second_cpu), &second_cpu);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_set_scheduler(task_id, scheduler_a_id, 1);
rtems_test_assert(sc == RTEMS_UNSATISFIED);
sc = rtems_task_get_scheduler(task_id, &scheduler_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
rtems_test_assert(scheduler_id == scheduler_b_id);
sc = rtems_semaphore_obtain(imtx_id, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_set_scheduler(task_id, scheduler_b_id, 1);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_start(task_id, task, 0);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_event_transient_receive(RTEMS_WAIT, RTEMS_NO_TIMEOUT);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
/* Ensure that the other task waits for the mutex owned by us */
sc = rtems_task_wake_after(2);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_set_scheduler(RTEMS_SELF, scheduler_b_id, 1);
rtems_test_assert(sc == RTEMS_RESOURCE_IN_USE);
sc = rtems_semaphore_release(imtx_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_event_transient_receive(RTEMS_WAIT, RTEMS_NO_TIMEOUT);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
}
sc = rtems_task_delete(task_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_semaphore_delete(cmtx_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_semaphore_delete(imtx_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
test_scheduler_add_remove_processors();
}
rtems_task Init(
rtems_task_argument argument
)
{
rtems_status_code status;
puts( "\n\n*** TEST 12 ***" );
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', ' ' );
Task_name[ 4 ] = rtems_build_name( 'T', 'A', '4', ' ' );
Task_name[ 5 ] = rtems_build_name( 'T', 'A', '5', ' ' );
Priority_task_name[ 1 ] = rtems_build_name( 'P', 'R', 'I', '1' );
Priority_task_name[ 2 ] = rtems_build_name( 'P', 'R', 'I', '2' );
Priority_task_name[ 3 ] = rtems_build_name( 'P', 'R', 'I', '3' );
Priority_task_name[ 4 ] = rtems_build_name( 'P', 'R', 'I', '4' );
Priority_task_name[ 5 ] = rtems_build_name( 'P', 'R', 'I', '5' );
Semaphore_name[ 1 ] = rtems_build_name( 'S', 'M', '1', ' ' );
Semaphore_name[ 2 ] = rtems_build_name( 'S', 'M', '2', ' ' );
Semaphore_name[ 3 ] = rtems_build_name( 'S', 'M', '3', ' ' );
status = rtems_semaphore_create(
Semaphore_name[ 1 ],
1,
RTEMS_DEFAULT_ATTRIBUTES,
RTEMS_NO_PRIORITY,
&Semaphore_id[ 1 ]
);
directive_failed( status, "rtems_semaphore_create of SM1" );
status = rtems_semaphore_create(
Semaphore_name[ 2 ],
0,
RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&Semaphore_id[ 2 ]
);
directive_failed( status, "rtems_semaphore_create of SM2" );
status = rtems_semaphore_create(
Semaphore_name[ 3 ],
1,
RTEMS_DEFAULT_ATTRIBUTES,
RTEMS_NO_PRIORITY,
&Semaphore_id[ 3 ]
);
directive_failed( status, "rtems_semaphore_create of SM3" );
puts( "INIT - Forward priority queue test" );
Priority_test_driver( 0 );
puts( "INIT - Backward priority queue test" );
Priority_test_driver( (RTEMS_MAXIMUM_PRIORITY / 2u) + 1u );
rtems_test_pause();
puts( "INIT - Binary Semaphore and Priority Inheritance Test" );
status = rtems_semaphore_delete( Semaphore_id[ 2 ] );
directive_failed( status, "rtems_semaphore_delete of SM2 #1" );
puts( "INIT - rtems_semaphore_create - allocated binary semaphore" );
status = rtems_semaphore_create(
Semaphore_name[ 2 ],
0,
RTEMS_BINARY_SEMAPHORE | RTEMS_PRIORITY | RTEMS_INHERIT_PRIORITY,
RTEMS_NO_PRIORITY,
&Semaphore_id[ 2 ]
);
directive_failed( status, "rtems_semaphore_create of priority inherit SM2" );
puts( "INIT - rtems_semaphore_release - allocated binary semaphore" );
status = rtems_semaphore_release( Semaphore_id[ 2 ] );
directive_failed( status, "rtems_semaphore_release of SM2" );
puts( "INIT - rtems_semaphore_delete - allocated binary semaphore" );
status = rtems_semaphore_delete( Semaphore_id[ 2 ] );
directive_failed( status, "rtems_semaphore_delete of SM2 #2" );
status = rtems_semaphore_create(
Semaphore_name[ 2 ],
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_PRIORITY | RTEMS_INHERIT_PRIORITY,
RTEMS_NO_PRIORITY,
&Semaphore_id[ 2 ]
);
directive_failed( status, "rtems_semaphore_create of priority inherit SM2" );
Priority_test_driver( PRIORITY_INHERIT_BASE_PRIORITY );
rtems_test_pause();
status = rtems_semaphore_delete( Semaphore_id[ 2 ] );
directive_failed( status, "rtems_semaphore_delete of SM2 #3" );
status = rtems_semaphore_create(
Semaphore_name[ 2 ],
0,
RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&Semaphore_id[ 2 ]
);
directive_failed( status, "rtems_semaphore_create of priority SM2" );
status = rtems_semaphore_release( Semaphore_id[ 2 ] );
directive_failed( status, "rtems_semaphore_release of SM2" );
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,
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,
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" );
status = rtems_task_delete( RTEMS_SELF );
directive_failed( status, "rtems_task_delete of RTEMS_SELF" );
}
