void Validate_setaffinity_errors(void)
{
int sc;
cpu_set_t cpuset;
/* Verify rtems_task_set_affinity checks that all cpu's exist. */
/* Note this check assumes you are running with less than 32 CPUs */
CPU_FILL(&cpuset);
puts( "Init - rtems_task_set_affinity - Lots of cpus - SUCCESS" );
sc = rtems_task_set_affinity( Init_id, sizeof(cpu_set_t), &cpuset );
rtems_test_assert( sc == RTEMS_SUCCESSFUL );
/* Verify rtems_task_set_affinity checks that at least one cpu is set */
CPU_ZERO(&cpuset);
puts( "Init - rtems_task_set_affinity - no cpu - RTEMS_INVALID_NUMBER" );
sc = rtems_task_set_affinity( Init_id, sizeof(cpu_set_t), &cpuset );
rtems_test_assert( sc == RTEMS_INVALID_NUMBER );
/* Verify rtems_task_set_affinity checks that at thread id is valid */
CPU_ZERO(&cpuset);
CPU_SET(0, &cpuset);
puts( "Init - rtems_task_set_affinity - Invalid thread - RTEMS_INVALID_ID" );
sc = rtems_task_set_affinity( 999, sizeof(cpu_set_t), &cpuset );
rtems_test_assert( sc == RTEMS_INVALID_ID );
/* Verify rtems_task_set_affinity validates cpusetsize */
puts( "Init - rtems_task_set_affinity - Invalid cpusetsize - RTEMS_INVALID_NUMBER" );
sc = rtems_task_set_affinity( Init_id, 1, &cpuset );
rtems_test_assert( sc == RTEMS_INVALID_NUMBER );
/* Verifyrtems_task_set_affinity validates cpuset */
puts( "Init - rtems_task_set_affinity - Invalid cpuset - RTEMS_INVALID_ADDRESS" );
sc = rtems_task_set_affinity( Init_id, sizeof(cpu_set_t), NULL );
rtems_test_assert( sc == RTEMS_INVALID_ADDRESS );
}
static void set_affinity(rtems_id id, uint32_t cpu_set_32)
{
rtems_status_code sc;
cpu_set_t cpu_set;
size_t i;
CPU_ZERO(&cpu_set);
for (i = 0; i < CPU_COUNT; ++i) {
if ((cpu_set_32 & (UINT32_C(1) << i)) != 0) {
CPU_SET(i, &cpu_set);
}
}
sc = rtems_task_set_affinity(id, sizeof(cpu_set), &cpu_set);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
}
int rtems_shell_main_task_set_affinity(
int argc,
char *argv[]
)
{
rtems_id id;
rtems_status_code status;
unsigned long tmp;
cpu_set_t cpuset;
CHECK_RTEMS_IS_UP();
if (argc != 3) {
fprintf( stderr, "%s: Usage [name|id] affinity\n", argv[0] );
return -1;
}
if ( lookup_task( argv[1], &id ) )
return -1;
if ( rtems_string_to_unsigned_long( argv[2], &tmp, NULL, 0) ) {
fprintf( stderr, "Affinity (%s) is not a number\n", argv[2] );
return 1;
}
CPU_ZERO( &cpuset );
cpuset.__bits[0] = tmp;
/*
* Now change the affinity of the task
*/
status = rtems_task_set_affinity( id, sizeof(cpuset), &cpuset );
if ( status != RTEMS_SUCCESSFUL ) {
fprintf(
stderr,
"Task Set Affinity(%s) returned %s\n",
argv[1],
rtems_status_text( status )
);
return -1;
}
printf("Task (0x%08x) Set affinity=0x%08x\n", id, cpuset.__bits[0] );
return 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();
}
static void test_task_get_set_affinity(void)
{
#if defined(__RTEMS_HAVE_SYS_CPUSET_H__)
rtems_id self_id = rtems_task_self();
rtems_id task_id;
rtems_status_code sc;
cpu_set_t cpusetone;
cpu_set_t cpuset;
size_t big = 2 * CHAR_BIT * sizeof(cpu_set_t);
size_t cpusetbigsize = CPU_ALLOC_SIZE(big);
cpu_set_t *cpusetbigone;
cpu_set_t *cpusetbig;
CPU_ZERO(&cpusetone);
CPU_SET(0, &cpusetone);
sc = rtems_task_create(
rtems_build_name('T', 'A', 'S', 'K'),
2,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&task_id
);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_get_affinity(RTEMS_SELF, sizeof(cpuset), NULL);
rtems_test_assert(sc == RTEMS_INVALID_ADDRESS);
sc = rtems_task_set_affinity(RTEMS_SELF, sizeof(cpuset), NULL);
rtems_test_assert(sc == RTEMS_INVALID_ADDRESS);
sc = rtems_task_get_affinity(RTEMS_SELF, 0, &cpuset);
rtems_test_assert(sc == RTEMS_INVALID_NUMBER);
sc = rtems_task_set_affinity(RTEMS_SELF, 0, &cpuset);
rtems_test_assert(sc == RTEMS_INVALID_NUMBER);
sc = rtems_task_get_affinity(invalid_id, sizeof(cpuset), &cpuset);
rtems_test_assert(sc == RTEMS_INVALID_ID);
sc = rtems_task_set_affinity(invalid_id, sizeof(cpuset), &cpuset);
rtems_test_assert(sc == RTEMS_INVALID_ID);
sc = rtems_task_get_affinity(RTEMS_SELF, sizeof(cpuset), &cpuset);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
rtems_test_assert(CPU_EQUAL(&cpuset, &cpusetone));
sc = rtems_task_set_affinity(RTEMS_SELF, sizeof(cpuset), &cpuset);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_set_affinity(self_id, sizeof(cpuset), &cpuset);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_set_affinity(task_id, sizeof(cpuset), &cpuset);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_get_affinity(task_id, sizeof(cpuset), &cpuset);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
rtems_test_assert(CPU_EQUAL(&cpuset, &cpusetone));
cpusetbigone = CPU_ALLOC(big);
rtems_test_assert(cpusetbigone != NULL);
cpusetbig = CPU_ALLOC(big);
rtems_test_assert(cpusetbig != NULL);
CPU_ZERO_S(cpusetbigsize, cpusetbigone);
CPU_SET_S(0, cpusetbigsize, cpusetbigone);
sc = rtems_task_get_affinity(task_id, cpusetbigsize, cpusetbig);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
rtems_test_assert(CPU_EQUAL_S(cpusetbigsize, cpusetbig, cpusetbigone));
sc = rtems_task_set_affinity(task_id, cpusetbigsize, cpusetbig);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_delete(task_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
CPU_FREE(cpusetbig);
CPU_FREE(cpusetbigone);
#endif /* defined(__RTEMS_HAVE_SYS_CPUSET_H__) */
}
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;
cpu_set_t cpuset;
cpu_set_t first_cpu;
cpu_set_t second_cpu;
cpu_set_t all_cpus;
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_ZERO(&all_cpus);
CPU_SET(0, &all_cpus);
CPU_SET(1, &all_cpus);
rtems_test_assert(rtems_get_current_processor() == 0);
sc = rtems_scheduler_ident(SCHED_A, &scheduler_a_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
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_UNSATISFIED);
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));
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, &first_cpu));
sc = rtems_task_set_scheduler(task_id, scheduler_b_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_set_scheduler(task_id, scheduler_b_id + 1);
rtems_test_assert(sc == RTEMS_INVALID_ID);
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, &second_cpu));
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(second_cpu), &second_cpu);
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);
sc = rtems_task_start(task_id, task, 0);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_set_scheduler(task_id, scheduler_b_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);
}
static void test(void)
{
rtems_status_code sc;
rtems_task_argument i;
size_t size;
uint32_t cpu_count;
rtems_task_priority priority;
/* Get the number of processors that we are using. */
cpu_count = rtems_get_processor_count();
if (cpu_count != 4) {
printf("Test requires a minimum of 4 cores\n");
return;
}
size = sizeof(cpu_set_t);
task_data[0].id = rtems_task_self();
printf("Create Semaphore\n");
sc = rtems_semaphore_create(
rtems_build_name('S', 'E', 'M', '0'),
1, /* initial count = 1 */
RTEMS_LOCAL |
RTEMS_SIMPLE_BINARY_SEMAPHORE |
RTEMS_NO_INHERIT_PRIORITY |
RTEMS_NO_PRIORITY_CEILING |
RTEMS_FIFO,
0,
&task_sem
);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
/* Create and start tasks on each cpu with the appropriate affinity. */
for (i = 1; i < TASK_COUNT; i++) {
sc = rtems_task_create(
rtems_build_name('T', 'A', '0', '0'+i),
task_data[ i ].priority,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&task_data[ i ].id
);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_set_affinity(
task_data[ i ].id,
size,
&task_data[i].cpuset
);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
printf(
"Start TA%d at priority %d on cpu %d\n",
i,
task_data[i].priority,
task_data[i].expected_cpu
);
sc = rtems_task_start( task_data[ i ].id, task, i );
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
}
/* spin for 100 ticks */
test_delay(100);
verify_tasks();
i = TASK_COUNT - 1;
task_data[ i ].priority = 4;
printf("Set TA%d priority %d\n", i,task_data[i].priority );
sc = rtems_task_set_priority(
task_data[ i ].id,
task_data[ i ].priority,
&priority
);
test_delay(25);
while( rtems_semaphore_obtain (task_sem, RTEMS_NO_WAIT, 0) != RTEMS_SUCCESSFUL );
for (i = 0; i < TASK_COUNT; i++) {
task_data[ i ].expected_cpu = task_data[ i ].migrate_cpu;
task_data[ i ].actual_cpu = -1;
task_data[ i ].ran = false;
}
rtems_semaphore_release(task_sem);
test_delay(25);
verify_tasks();
}
static void test(uint32_t cpu_count)
{
rtems_status_code sc;
uint32_t t;
uint32_t c;
rtems_task_argument idx;
cpu_set_t cpu_set;
/* Semaphore to signal end of test */
sc = rtems_semaphore_create(rtems_build_name('D', 'o', 'n', 'e'), 0,
RTEMS_LOCAL |
RTEMS_NO_INHERIT_PRIORITY |
RTEMS_NO_PRIORITY_CEILING |
RTEMS_FIFO, 0, &finished_sem);
/*
* Create a set of tasks per CPU. Chain them together using
* semaphores so that only one task can be active at any given
* time.
*/
for ( c = 0; c < cpu_count; c++ ) {
for ( t = 0; t < TASKS_PER_CPU; t++ ) {
idx = c * TASKS_PER_CPU + t;
sc = rtems_task_create(rtems_build_name('T', 'A', '0' + c, '0' + t),
TASK_PRIO,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&task_data[idx].id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_semaphore_create(rtems_build_name('S', 'E', '0' + c, '0' + t),
0,
RTEMS_LOCAL |
RTEMS_SIMPLE_BINARY_SEMAPHORE |
RTEMS_NO_INHERIT_PRIORITY |
RTEMS_NO_PRIORITY_CEILING |
RTEMS_FIFO, 0, &task_data[idx].task_sem);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
task_data[(idx + 1) % (cpu_count * TASKS_PER_CPU)].prev_sem =
task_data[idx].task_sem;
CPU_ZERO_S(sizeof(cpu_set_t), &cpu_set);
CPU_SET_S(c, sizeof(cpu_set_t), &cpu_set);
sc = rtems_task_set_affinity(task_data[idx].id, sizeof(cpu_set_t),
&cpu_set);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
}
}
/* Start the tasks */
for ( idx = 0; idx < cpu_count * TASKS_PER_CPU; idx++ ) {
sc = rtems_task_start(task_data[idx].id, task, idx);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
}
/* Start chain */
sc = rtems_semaphore_release(task_data[0].task_sem);
/* Wait until chain has completed */
for ( idx = 0; idx < cpu_count * TASKS_PER_CPU; idx++ ) {
rtems_semaphore_obtain(finished_sem, 0, 0);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
}
}
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;
uint32_t cpu_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_ZERO(&all_cpus);
CPU_SET(0, &all_cpus);
CPU_SET(1, &all_cpus);
cpu_count = rtems_get_processor_count();
rtems_test_assert(rtems_get_current_processor() == 0);
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_UNSATISFIED);
sc = rtems_semaphore_create(
SCHED_A,
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_PRIORITY | RTEMS_PRIORITY_CEILING,
1,
&sema_id
);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
prio = 2;
sc = rtems_semaphore_set_priority(sema_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(sema_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, &first_cpu));
rtems_test_assert(sched_get_priority_min(SCHED_RR) == 1);
rtems_test_assert(sched_get_priority_max(SCHED_RR) == 254);
if (cpu_count > 1) {
sc = rtems_task_set_scheduler(task_id, scheduler_b_id, 1);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
sc = rtems_task_set_scheduler(task_id, scheduler_b_id + 1, 1);
rtems_test_assert(sc == RTEMS_INVALID_ID);
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, &second_cpu));
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(second_cpu), &second_cpu);
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);
sc = rtems_task_start(task_id, task, 0);
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_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(sema_id);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
}
void Validate_affinity(void )
{
cpu_set_t cpuset0;
cpu_set_t cpuset1;
cpu_set_t cpuset2;
uint32_t i;
int sc;
int cpu_count;
rtems_task_priority priority;
char ch[2];
puts( "Init - Set Init priority to high");
sc = rtems_task_set_priority( Init_id, 1, &priority );
directive_failed( sc, "Set Init Priority" );
sc = rtems_task_get_affinity( Init_id, sizeof(cpu_set_t), &cpuset0 );
directive_failed( sc, "Get Affinity of Init Task" );
/* Get the number of processors that we are using. */
cpu_count = rtems_get_processor_count();
/* Fill the remaining cpus with med priority tasks */
puts( "Init - Create Medium priority tasks");
for (i=0; i<(cpu_count-1); i++){
sprintf(ch, "%01" PRId32, i+1 );
sc = rtems_task_create(
rtems_build_name( 'C', 'P', 'U', ch[0] ),
2,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&Med_id[i]
);
directive_failed( sc, "task create" );
sc = rtems_task_start( Med_id[i], Task_1, i+1 );
directive_failed( sc, "task start" );
sc = rtems_task_get_affinity( Med_id[i], sizeof(cpu_set_t), &cpuset2 );
directive_failed( sc, "Get Affinity of Medium Priority Task" );
rtems_test_assert( CPU_EQUAL(&cpuset0, &cpuset2) );
}
/*
* Create low priority thread for each remaining cpu with the affinity
* set to only run on one cpu.
*/
puts( "Init - Create Low priority tasks");
for (i=0; i<cpu_count; i++){
CPU_ZERO(&cpuset1);
CPU_SET(i, &cpuset1);
sprintf(ch, "%01" PRId32, (uint32_t) 0 );
sc = rtems_task_create(
rtems_build_name( 'X', 'T', 'R', ch[0] ),
10,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&Low_id[i]
);
directive_failed( sc, "task create" );
sc = rtems_task_set_affinity( Low_id[i], sizeof(cpu_set_t), &cpuset1 );
directive_failed( sc, "Low priority task set affinity" );
sc = rtems_task_start( Low_id[i], Task_1, i+1 );
directive_failed( sc, "task start" );
}
/* Verify affinity on low priority tasks */
puts("Init - Verify affinity on Low priority tasks");
for (i=0; i<cpu_count; i++){
CPU_ZERO(&cpuset1);
CPU_SET(i, &cpuset1);
sc = rtems_task_get_affinity( Low_id[i], sizeof(cpu_set_t), &cpuset2 );
directive_failed( sc, "Low priority task get affinity" );
rtems_test_assert( CPU_EQUAL(&cpuset1, &cpuset2) );
}
/* Change the affinity for each low priority task */
puts("Init - Change affinity on Low priority tasks");
CPU_COPY(&cpuset0, &cpuset1);
for (i=0; i<cpu_count; i++){
CPU_CLR(i, &cpuset1);
sc = rtems_task_set_affinity( Low_id[i], sizeof(cpu_set_t), &cpuset1 );
/* Verify no cpu's are now set in the cpuset */
if (i== (cpu_count-1)) {
rtems_test_assert( sc == RTEMS_INVALID_NUMBER );
sc = rtems_task_set_affinity( Low_id[i], sizeof(cpu_set_t), &cpuset0 );
}
directive_failed( sc, "Low priority task set affinity" );
}
puts("Init - Validate affinity on Low priority tasks");
CPU_COPY(&cpuset0, &cpuset1);
for (i=0; i<cpu_count; i++){
CPU_CLR(i, &cpuset1);
sc = rtems_task_get_affinity( Low_id[i], sizeof(cpu_set_t), &cpuset2 );
directive_failed( sc, "Low priority task get affinity" );
if (i== (cpu_count-1))
rtems_test_assert( CPU_EQUAL(&cpuset0, &cpuset2) );
else
rtems_test_assert( CPU_EQUAL(&cpuset1, &cpuset2) );
}
}
static void test(void)
{
rtems_status_code sc;
uint32_t cpu_count;
int cpu;
int i;
cpu_set_t cpuset;
/* Get the number of processors that we are using. */
cpu_count = rtems_get_processor_count();
if (cpu_count < 2) {
printf("Error: Test requires at least 2 cpus\n");
return;
}
printf("Create Semaphore\n");
sc = rtems_semaphore_create(
rtems_build_name('S', 'E', 'M', '0'),
1, /* initial count = 1 */
RTEMS_LOCAL |
RTEMS_SIMPLE_BINARY_SEMAPHORE |
RTEMS_NO_INHERIT_PRIORITY |
RTEMS_NO_PRIORITY_CEILING |
RTEMS_FIFO,
0,
&task_sem
);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
/*
* Create and start TA1 at a higher priority
* than the init task.
*/
sc = rtems_task_create(
rtems_build_name('T', 'A', '0', '1'),
4,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_MODES,
RTEMS_DEFAULT_ATTRIBUTES,
&task_data.id
);
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
printf("Start TA1\n");
sc = rtems_task_start( task_data.id, task, 0 );
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
/*
* Verify the Init task is running on the max core.
*/
printf("Verify Init task is on cpu %ld\n",cpu_count-1);
cpu = rtems_get_current_processor();
rtems_test_assert(cpu == (cpu_count-1));
/* Walk TA1 across all of the cores */
for(i=0; i < cpu_count; i++) {
/* Set the Affinity to core i */
CPU_ZERO(&cpuset);
CPU_SET(i, &cpuset);
printf("Set Affinity TA1 to cpu %d\n", i);
sc = rtems_task_set_affinity( task_data.id, sizeof(cpuset), &cpuset );
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
/* Wait a bit to be sure it has switched cores then clear the task data */
test_delay(50);
while( rtems_semaphore_obtain (task_sem, RTEMS_NO_WAIT, 0) != RTEMS_SUCCESSFUL );
task_data.ran = false;
task_data.expected_cpu = i;
rtems_semaphore_release(task_sem);
test_delay(50);
/* Verify the task ran on core i */
while( rtems_semaphore_obtain (task_sem, RTEMS_NO_WAIT, 0) != RTEMS_SUCCESSFUL );
if (task_data.ran != true)
printf("Error: TA01 never ran.\n");
else
printf(
"TA1 expected cpu: %d actual cpu %d\n",
task_data.expected_cpu,
task_data.actual_cpu
);
rtems_test_assert(task_data.ran == true);
rtems_test_assert(task_data.expected_cpu == task_data.actual_cpu);
rtems_semaphore_release(task_sem);
}
}
