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); } }