/* 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);
}
/*
* Alloc pipe control structure, buffer, and resources.
* Called with pipe_semaphore held.
*/
static int pipe_alloc(
pipe_control_t **pipep
)
{
static char c = 'a';
pipe_control_t *pipe;
int err = -ENOMEM;
pipe = malloc(sizeof(pipe_control_t));
if (pipe == NULL)
return err;
memset(pipe, 0, sizeof(pipe_control_t));
pipe->Size = PIPE_BUF;
pipe->Buffer = malloc(pipe->Size);
if (! pipe->Buffer)
goto err_buf;
err = -ENOMEM;
if (rtems_barrier_create(
rtems_build_name ('P', 'I', 'r', c),
RTEMS_BARRIER_MANUAL_RELEASE, 0,
&pipe->readBarrier) != RTEMS_SUCCESSFUL)
goto err_rbar;
if (rtems_barrier_create(
rtems_build_name ('P', 'I', 'w', c),
RTEMS_BARRIER_MANUAL_RELEASE, 0,
&pipe->writeBarrier) != RTEMS_SUCCESSFUL)
goto err_wbar;
if (rtems_semaphore_create(
rtems_build_name ('P', 'I', 's', c), 1,
RTEMS_BINARY_SEMAPHORE | RTEMS_FIFO,
RTEMS_NO_PRIORITY, &pipe->Semaphore) != RTEMS_SUCCESSFUL)
goto err_sem;
#ifdef RTEMS_POSIX_API
pipe_interruptible(pipe);
#endif
*pipep = pipe;
if (c ++ == 'z')
c = 'a';
return 0;
err_sem:
rtems_barrier_delete(pipe->writeBarrier);
err_wbar:
rtems_barrier_delete(pipe->readBarrier);
err_rbar:
free(pipe->Buffer);
err_buf:
free(pipe);
return err;
}
void delete_barrier(void)
{
rtems_status_code status;
BarrierCount--;
printf( "Deleting barrier id=0x%08x\n",
(unsigned int)Barriers[BarrierCount] );
status = rtems_barrier_delete( Barriers[BarrierCount] );
directive_failed( status, "barrier delete" );
}
static void benchmark_barrier_delete(
int iteration,
void *argument
)
{
rtems_status_code status;
status = rtems_barrier_delete( barrier[iteration] );
directive_failed(status, "rtems_barrier_delete");
}
static void Init(rtems_task_argument arg)
{
test_context *ctx = &test_instance;
rtems_status_code sc;
rtems_resource_snapshot snapshot;
uint32_t cpu_count = rtems_get_processor_count();
uint32_t cpu_index;
TEST_BEGIN();
rtems_resource_snapshot_take(&snapshot);
sc = rtems_barrier_create(
rtems_build_name('B', 'A', 'R', 'I'),
RTEMS_BARRIER_AUTOMATIC_RELEASE,
cpu_count,
&ctx->barrier_id
);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
for (cpu_index = 1; cpu_index < cpu_count; ++cpu_index) {
rtems_id scheduler_id;
sc = rtems_task_create(
rtems_build_name('T', 'A', 'S', 'K'),
1,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&ctx->task_id[cpu_index]
);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_scheduler_ident(SCHED_NAME(cpu_index), &scheduler_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_set_scheduler(ctx->task_id[cpu_index], scheduler_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_start(ctx->task_id[cpu_index], test_task, cpu_index);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
}
tests();
barrier_wait(ctx);
sc = rtems_barrier_delete(ctx->barrier_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
done(0);
for (cpu_index = 1; cpu_index < cpu_count; ++cpu_index) {
sc = rtems_task_delete(ctx->task_id[cpu_index]);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
rtems_test_assert(ctx->cpu_index[cpu_index] == cpu_index);
done(cpu_index);
}
rtems_test_assert(rtems_resource_snapshot_check(&snapshot));
TEST_END();
rtems_test_exit(0);
}
rtems_task Init(
rtems_task_argument ignored
)
{
rtems_status_code status;
rtems_name name = rtems_build_name('B','A','R','1');
uint32_t released;
rtems_id testId;
rtems_id Tasks[CONFIGURE_MAXIMUM_TASKS-1];
uint32_t i;
TEST_BEGIN();
/* Check bad argument cases */
puts( "rtems_barrier_delete - bad id - INVALID_ID" );
status = rtems_barrier_delete( 100 );
fatal_directive_status(
status,
RTEMS_INVALID_ID,
"rtems_barrier_delete did not return RTEMS_INVALID_ID"
);
puts( "rtems_barrier_release - bad id - INVALID_ID" );
status = rtems_barrier_release( 100, &released );
fatal_directive_status(
status,
RTEMS_INVALID_ID,
"rtems_barrier_release did not return RTEMS_INVALID_ID"
);
puts( "rtems_barrier_wait - bad id - INVALID_ID" );
status = rtems_barrier_wait( 100, 10 );
fatal_directive_status(
status,
RTEMS_INVALID_ID,
"rtems_barrier_wait did not return RTEMS_INVALID_ID"
);
/* Create barrier with automatic release and 0 maximum waiters */
puts( "Create barrier with automatic release and 0 max waiters" );
status = rtems_barrier_create(
name, RTEMS_BARRIER_AUTOMATIC_RELEASE, 0, &Barrier
);
fatal_directive_status(
status,
RTEMS_INVALID_NUMBER,
"rtems_barrier_create did not return RTEMS_INVALID_NUMBER"
);
/* create barrier with bad name */
puts( "rtems_barrier_create - bad name - INVALID_NAME" );
status = rtems_barrier_create(
0, RTEMS_BARRIER_AUTOMATIC_RELEASE, 1, &Barrier);
fatal_directive_status(
status,
RTEMS_INVALID_NAME,
"rtems_barrier_create did not return RTEMS_INVALID_NAME"
);
/* create barrier with bad id return address */
puts( "rtems_barrier_create - NULL barrier ID - INVALID_ADDRESS" );
status = rtems_barrier_create(name, RTEMS_BARRIER_AUTOMATIC_RELEASE, 1, NULL);
fatal_directive_status(
status,
RTEMS_INVALID_ADDRESS,
"rtems_barrier_create did not return RTEMS_INVALID_ADDRESS"
);
/* Create barrier */
puts( "rtems_barrier_create - OK" );
status = rtems_barrier_create( name, RTEMS_DEFAULT_ATTRIBUTES, 0, &Barrier );
directive_failed(status, "rtems_barrier_create");
/* Check for creating too many */
puts( "rtems_barrier_create - too many" );
status = rtems_barrier_create( name, RTEMS_DEFAULT_ATTRIBUTES, 0, &Barrier );
fatal_directive_status(
status,
RTEMS_TOO_MANY,
"rtems_barrier_create did not return RTEMS_TOO_MANY"
);
puts( "Check barrier ident" );
status = rtems_barrier_ident( name, &testId );
directive_failed(status, "rtems_barrier_ident");
if ( testId != Barrier ) {
printf( "ERROR -- rtems_barrier_create -- did not get Id expected\n" );
exit( 0 );
}
puts( "Wait on barrier w/timeout and TIMEOUT" );
status = rtems_barrier_wait( Barrier, 25 );
fatal_directive_status(
status,
RTEMS_TIMEOUT,
"rtems_barrier_wait did not timeout"
);
/* Release with bad return pointer */
puts( "rtems_barrier_release - NULL return count - INVALID_ADDRESS" );
status = rtems_barrier_release( Barrier, NULL );
fatal_directive_status(
status,
RTEMS_INVALID_ADDRESS,
"rtems_barrier_release bad return pointer"
);
/* Release no tasks */
status = rtems_barrier_release( Barrier, &released );
directive_failed(status, "rtems_barrier_release");
if ( released != 0 ) {
printf(
"ERROR -- rtems_barrier_release -- released != 0, = %" PRIu32,
released
);
rtems_test_exit(0);
}
/* Create some tasks to wait for the barrier */
SuccessfulCase = TRUE;
DeletedCase = FALSE;
puts( "\n*** Testing manual release of barrier ***" );
for (i=0 ; i<(CONFIGURE_MAXIMUM_TASKS-1) ; i++) {
status = rtems_task_create(
rtems_build_name('W','A','I','T'),
1,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&Tasks[ i ]
);
directive_failed( status, "rtems_task_create of Waiter" );
status = rtems_task_start( Tasks[ i ], Waiter, i );
directive_failed( status, "rtems_task_start of Waiter" );
}
puts( "Delay to let Waiters block" );
status = rtems_task_wake_after( rtems_clock_get_ticks_per_second() );
directive_failed(status, "rtems_task_wake_after");
/* Release tasks which were waiting */
puts( "Releasing tasks" );
status = rtems_barrier_release( Barrier, &released );
directive_failed(status, "rtems_barrier_release");
if ( released != (CONFIGURE_MAXIMUM_TASKS-1) ) {
printf(
"ERROR -- rtems_barrier_release -- released != %d, = %" PRIu32,
(CONFIGURE_MAXIMUM_TASKS-1),
released
);
rtems_test_exit(0);
}
puts( "Delay to let Waiters print a message" );
status = rtems_task_wake_after( rtems_clock_get_ticks_per_second() );
directive_failed(status, "rtems_task_wake_after");
/* Create some tasks to wait for the barrier */
SuccessfulCase = FALSE;
DeletedCase = TRUE;
puts( "\n*** Testing Deletion of barrier ***" );
for (i=0 ; i<(CONFIGURE_MAXIMUM_TASKS-1) ; i++) {
status = rtems_task_create(
rtems_build_name('W','A','I','T'),
1,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&Tasks[ i ]
);
directive_failed( status, "rtems_task_create of Waiter" );
status = rtems_task_start( Tasks[ i ], Waiter, i );
directive_failed( status, "rtems_task_start of Waiter" );
}
puts( "Delay to let Waiters block" );
status = rtems_task_wake_after( rtems_clock_get_ticks_per_second() );
directive_failed(status, "rtems_task_wake_after");
puts( "rtems_barrier_delete - OK" );
status = rtems_barrier_delete( Barrier );
directive_failed(status, "rtems_barrier_delete");
puts( "Delay to let Waiters print a message" );
status = rtems_task_wake_after( rtems_clock_get_ticks_per_second() );
directive_failed(status, "rtems_task_wake_after");
/* Create barrier with automatic release */
puts( "rtems_barrier_create - OK" );
status = rtems_barrier_create(
name, RTEMS_BARRIER_AUTOMATIC_RELEASE, CONFIGURE_MAXIMUM_TASKS-1, &Barrier
);
directive_failed(status, "rtems_barrier_create");
/* Create some tasks to wait for the barrier */
SuccessfulCase = TRUE;
DeletedCase = FALSE;
puts( "\n*** Testing automatic release of barrier ***" );
for (i=0 ; i<(CONFIGURE_MAXIMUM_TASKS-1) ; i++) {
status = rtems_task_create(
rtems_build_name('W','A','I','T'),
1,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&Tasks[ i ]
);
directive_failed( status, "rtems_task_create of Waiter" );
status = rtems_task_start( Tasks[ i ], Waiter, i );
directive_failed( status, "rtems_task_start of Waiter" );
}
puts( "Delay to let task wait on barrier" );
status = rtems_task_wake_after( rtems_clock_get_ticks_per_second() );
directive_failed(status, "rtems_task_wake_after");
/* the end */
TEST_END();
rtems_test_exit(0);
}
