/* * Copyright (c) 2021, Google Inc. All rights reserved * * Permission is hereby granted, free of charge, to any person obtaining * a copy of this software and associated documentation files * (the "Software"), to deal in the Software without restriction, * including without limitation the rights to use, copy, modify, merge, * publish, distribute, sublicense, and/or sell copies of the Software, * and to permit persons to whom the Software is furnished to do so, * subject to the following conditions: * * The above copyright notice and this permission notice shall be * included in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ #define LOCAL_TRACE (0) #include #include #include #include #include #include #include #include #include #define PINCPU_TEST_CPU_COUNT 4 /* * Test verifying cpu pinning on any thread state * Make sure cpu pinning can be dynamically set on * a running, ready, blocked or sleeping thread. */ /** * struct pincputest_thread_ctx_main - main thread context structure * @test_state: Current test state * @thread: `main` thread's thread structure * @ev_req: Request event sent by the unittest thread to * the main thread in order to start a new test * @ev_resp: Response event sent by the main thread to * the unittest thread when the test case is * complete * @runningstate_lock: Spin_lock used to ensure the unittest thread * waits in running state. This is used to keep * the peer thread in ready state. * @cpu_expected: Cpu on which the main thread is pinned to and * shall be running on when setting the peer * thread's pinned cpu. * @actual_pinned_cpu: Peer thread's pinned cpu as seen by the main * thread when the thread_set_pinned_cpu is complete */ struct pincputest_thread_ctx_main { void* test_state; thread_t* thread; event_t ev_req; event_t ev_resp; spin_lock_t runningstate_lock; int cpu_expected; int actual_pinned_cpu; }; /** * struct pincputest_thread_ctx_peer - peer thread context structure * @test_state: Current test state * @thread: `peer` thread's thread structure * @ev_req: Request event sent by the main thread to * the peer thread. * @ev_resp: Response event sent by the peer thread to * the main thread * @blockingstate_mutex: Mutex used to set the peer thread * in blocking state * @blockingstate_event: Event used to set the peer thread * in blocking state, as an additional option * to the mutex. * @runningstate_lock: Spin_lock used to set the peer thread * in running state. * @cpu_expected: Cpu on which the peer thread is pinned to. * @cpu_actual: Cpu on which the peer thread is running * after handling the request event * from the main thread */ struct pincputest_thread_ctx_peer { void* test_state; thread_t* thread; event_t ev_req; event_t ev_resp; mutex_t blockingstate_mutex; event_t blockingstate_event; spin_lock_t runningstate_lock; int cpu_expected; int cpu_actual; }; /** * struct pincputest_t - test state structure for the pincputest * @is_rt_main: If true, main thread is real-time * @is_rt_peer: If true, peer thread is real-time * @pinned_is_current: If true, main thread sets the peer * thread's pinned cpu to the current cpu * @priority_main: Priority of the main thread * @priority_peer: Priority of the peer thread * @expected_state_peer: Expected thread state * (running/ready/blocked/sleeping) * for the peer thread to be in when * its cpu pinning is updated * @blockingstate_use_mutex: If true, the peer thread blocks on a mutex, * If false, it blocks on an event. * @ctx_main: main thread context * @ctx_peer: peer thread context * The pincputest consists of a `main` thread setting cpu pinning * on a `peer` thread. The test covers main and peer threads * being standard or realtime threads and having different relative priorities. */ typedef struct { bool is_rt_main; bool is_rt_peer; bool pinned_is_current; int priority_main; int priority_peer; enum thread_state expected_state_peer; bool blockingstate_use_mutex; struct pincputest_thread_ctx_main ctx_main; struct pincputest_thread_ctx_peer ctx_peer; } pincputest_t; static const char* thread_state_to_str(enum thread_state state) { switch (state) { case THREAD_SUSPENDED: return "Suspended"; case THREAD_READY: return "Ready"; case THREAD_RUNNING: return "Running"; case THREAD_BLOCKED: return "Blocked"; case THREAD_SLEEPING: return "Sleeping"; case THREAD_DEATH: return "Death"; default: return "Unknown"; } } static void pincputest_param_to_string(const void* param) { const void* const* params = param; TRACEF("[main:%s(%d), peer:%s(%d)]\n", *(bool*)params[0] ? "rt" : "std", *(int*)params[2], *(bool*)params[1] ? "rt" : "std", *(int*)params[3]); } /** * pincputest_unittest_thread() is the controller test function * invoked from the unittest thread. * It will ensure that the peer thread is in a given state * before the main thread invoked thread_set_pinned_cpu on the peer thread */ static void pincputest_unittest_thread(pincputest_t* _state) { struct pincputest_thread_ctx_main* ctx_main = &_state->ctx_main; struct pincputest_thread_ctx_peer* ctx_peer = &_state->ctx_peer; spin_lock_saved_state_t lock_state_main; spin_lock_saved_state_t lock_state_peer; ctx_main->test_state = _state; ctx_peer->test_state = _state; int cpu_peer = -1; /* current cpu for the peer thread */ ctx_peer->cpu_expected = -1; /* new target/pinned cpu for the peer thread */ ctx_main->cpu_expected = -1; /* target cpu for the main thread */ /* * set current thread's priority just higher from peer: * this thread (the unittest thread) handles the * necessary locking / unlocking for the peer thread * to reach the desired state. * So the unittest thread shall be either same priority * than peer if non real-time (with time slicing * / collaborative multi-threading), or higher priority * in case peer is a real-time thead. * To make things simpler, we set its priority higher * than the peer thread */ thread_set_priority(_state->priority_peer + 1); for (int c = 0; c <= PINCPU_TEST_CPU_COUNT; c++) { /* reset actual_pinned_cpu: * [-1..PINCPU_TEST_CPU_COUNT-1] are all valid values * PINCPU_TEST_CPU_COUNT can thus be used as the reset value */ ctx_main->actual_pinned_cpu = PINCPU_TEST_CPU_COUNT; cpu_peer = ctx_peer->cpu_actual == -1 ? 0 : ctx_peer->cpu_actual; if (thread_pinned_cpu(ctx_peer->thread) == -1) { /* this case can only happen at the beginning of the test */ DEBUG_ASSERT(c == 0); thread_set_pinned_cpu(ctx_peer->thread, cpu_peer); } DEBUG_ASSERT(thread_pinned_cpu(ctx_peer->thread)== cpu_peer); /* * define the new target pinned cpu * for both peer and main threads */ ctx_peer->cpu_expected = (cpu_peer + 1) % PINCPU_TEST_CPU_COUNT; if (_state->pinned_is_current) { ctx_main->cpu_expected = ctx_peer->cpu_expected; } else { ctx_main->cpu_expected = (cpu_peer + 2) % PINCPU_TEST_CPU_COUNT; } thread_set_pinned_cpu(ctx_main->thread, ctx_main->cpu_expected); if (c == PINCPU_TEST_CPU_COUNT) { /* for the last round, unpin peer thread */ ctx_peer->cpu_expected = -1; } /* * `unittest` thread shall be pinned to same cpu * as `peer` thread when peer expected state is * ready, blocked or sleeping. * However if the expected state is running, the * unittest thread shall be pinned to another cpu * (another than current and new pinned target cpu) */ if (_state->expected_state_peer == THREAD_RUNNING) { thread_set_pinned_cpu(get_current_thread(), (cpu_peer + 3) % PINCPU_TEST_CPU_COUNT); } else { thread_set_pinned_cpu(get_current_thread(), cpu_peer); } /* * In unit-test environment, ensure all cpus are idle before * starting the test. We actually want the cpu on which to pin the * peer thread to be idle when thread_set_pinned_cpu is invoked, as * this is the most complex scheduling state. */ thread_sleep_ns(100000000); /* wait 100ms for tgt cpu to be idle */ /* start the test by prepping * the locking states for the peer thread */ if (_state->expected_state_peer == THREAD_BLOCKED && _state->blockingstate_use_mutex) { mutex_acquire(&ctx_peer->blockingstate_mutex); } /* * notify the peer thread of a new test: * the peer thread will take the right * action to reach its expected state * before the main thread invokes * thread_set_pinned_cpu() */ LTRACEF("ev_req sent to peer (pinned_cpu=%d curr_cpu=%d)\n", thread_pinned_cpu(get_current_thread()), arch_curr_cpu_num()); event_signal(&ctx_peer->ev_req, true); /* * then notify the main thread * to invoke thread_set_pinned_cpu */ LTRACEF("ev_req sent to main (pinned_cpu=%d curr_cpu=%d)\n", thread_pinned_cpu(get_current_thread()), arch_curr_cpu_num()); event_signal(&ctx_main->ev_req, true); /* now wait for the main thread to invoke * the cpu pinning on the peer thread * if main thread is not supposed to be * preempted by the peer thread, simply * wait for the response event. * however if main thread is preempted while * right away (due to a higher priority peer thread) * peer thread needs to be unlocked as soon * as peer thread is pinned to new cpu and main thread * is in ready state */ bool main_preempted = false; if ((ctx_peer->cpu_expected > -1) && (_state->expected_state_peer == THREAD_RUNNING)) { if (_state->priority_main < _state->priority_peer) { main_preempted = true; } } if (main_preempted) { // thread_sleep_ns(1000000000); // sleep 1sec volatile int* peer_cpu_ptr = &ctx_peer->cpu_actual; int peer_cpu; int busy_loop_cnt = 0; do { spin_lock_irqsave(&ctx_peer->runningstate_lock, lock_state_peer); peer_cpu = *peer_cpu_ptr; spin_unlock_irqrestore(&ctx_peer->runningstate_lock, lock_state_peer); if (peer_cpu != ctx_peer->cpu_expected && ++busy_loop_cnt % 10000 == 0) { LTRACEF("%s: thread %s, actual_cpu [%d] != expected_cpu [%d], keep waiting...\n", __func__, ctx_peer->thread->name, peer_cpu, ctx_peer->cpu_expected); } } while (peer_cpu != ctx_peer->cpu_expected); LTRACEF("%s: thread %s, curr_cpu [%d] == expected_cpu [%d]!\n", __func__, ctx_peer->thread->name, peer_cpu, ctx_peer->cpu_expected); } else if (_state->expected_state_peer == THREAD_READY) { /* * for peer thread to be in READY state, the higher priority * unittest thread shall be busy on the same cpu as the peer thread * until the main thread is done with the pinned cpu request. * loop until the peer thread pinning completes. */ volatile int* peer_pinned_cpu_ptr = &ctx_main->actual_pinned_cpu; int peer_cpu; // int busy_loop_cnt = 0; do { spin_lock_irqsave(&ctx_main->runningstate_lock, lock_state_main); peer_cpu = *peer_pinned_cpu_ptr; spin_unlock_irqrestore(&ctx_main->runningstate_lock, lock_state_main); /* note: do not add LTRACEF statement as the thread will * become BLOCKED and the expected peer thread state * will not be gguaranted!! */ } while (peer_cpu != ctx_peer->cpu_expected); LTRACEF("ev_resp from main waiting...\n"); event_wait(&ctx_main->ev_resp); LTRACEF("ev_resp from main received!\n"); } else { LTRACEF("ev_resp from main waiting...\n"); event_wait(&ctx_main->ev_resp); LTRACEF("ev_resp from main received!\n"); } /* unblock the peer thread for it * to complete the test * (report its actual cpu) */ if (_state->expected_state_peer == THREAD_BLOCKED && _state->blockingstate_use_mutex) { mutex_release(&ctx_peer->blockingstate_mutex); } else if (_state->expected_state_peer == THREAD_BLOCKED && !_state->blockingstate_use_mutex) { event_signal(&ctx_peer->blockingstate_event, true); } event_wait(&ctx_peer->ev_resp); if (main_preempted) { event_wait(&ctx_main->ev_resp); } thread_sleep_ns(100000000); /* wait 100ms for tgt cpu to be idle */ LTRACEF("%s[%s] / %s[%s]\n", ctx_main->thread->name, thread_state_to_str(ctx_main->thread->state), ctx_peer->thread->name, thread_state_to_str(ctx_peer->thread->state)); DEBUG_ASSERT(ctx_main->thread->state == THREAD_BLOCKED); DEBUG_ASSERT(ctx_peer->thread->state == THREAD_BLOCKED); if (ctx_peer->cpu_expected > -1) { ASSERT_EQ(ctx_peer->cpu_expected, ctx_peer->cpu_actual); } else { ASSERT_GT(ctx_peer->cpu_actual, -1); } LTRACEF("%s: cpu expected (%d) actual (%d)\n**********************\n", __func__, ctx_peer->cpu_expected, ctx_peer->cpu_actual); } test_abort: thread_set_priority(HIGH_PRIORITY); thread_set_pinned_cpu(get_current_thread(), -1); ctx_main->test_state = NULL; ctx_peer->test_state = NULL; } static int pincputest_main_thread(void* _state) { pincputest_t* state = _state; struct pincputest_thread_ctx_main* ctx = &state->ctx_main; struct pincputest_thread_ctx_peer* ctx_peer = &state->ctx_peer; spin_lock_saved_state_t lock_state_main; while (1) { LTRACEF("ev_req waiting in main (pinned_cpu=%d curr_cpu=%d)\n", thread_pinned_cpu(get_current_thread()), arch_curr_cpu_num()); event_wait(&ctx->ev_req); LTRACEF("ev_req received in main (pinned_cpu=%d curr_cpu=%d)\n", thread_pinned_cpu(get_current_thread()), arch_curr_cpu_num()); DEBUG_ASSERT(_state); if (state->expected_state_peer == THREAD_DEATH) { /* exiting */ LTRACEF("main thread exiting...\n"); event_signal(&ctx->ev_resp, true); return 0; } thread_set_priority(state->priority_main); while (_state && ctx_peer->thread->state != state->expected_state_peer) { thread_sleep_ns(10000000); // sleep 10ms if (ctx_peer->thread->state != state->expected_state_peer) { LTRACEF("%s: thread %s, state [%s] != expected [%s], keep waiting...\n", __func__, ctx_peer->thread->name, thread_state_to_str(ctx_peer->thread->state), thread_state_to_str(state->expected_state_peer)); } } DEBUG_ASSERT(_state); if (ctx->cpu_expected > -1) { ASSERT_EQ(thread_curr_cpu(get_current_thread()), ctx->cpu_expected); } if (ctx_peer->cpu_expected == -1) { thread_set_pinned_cpu(get_current_thread(), -1); } thread_set_pinned_cpu(ctx_peer->thread, ctx_peer->cpu_expected); spin_lock_irqsave(&ctx->runningstate_lock, lock_state_main); ctx->actual_pinned_cpu = thread_pinned_cpu(ctx_peer->thread); spin_unlock_irqrestore(&ctx->runningstate_lock, lock_state_main); event_signal(&ctx->ev_resp, true); LTRACEF("ev_resp sent...\n"); DEBUG_ASSERT(_state); test_abort:; thread_set_priority(HIGH_PRIORITY); } return 0; } static int pincputest_peer_thread(void* _state) { pincputest_t* state = _state; struct pincputest_thread_ctx_peer* ctx = &state->ctx_peer; spin_lock_saved_state_t lock_state_peer; int pinned_cpu; int curr_cpu; bool done; while (1) { LTRACEF("ev_req waiting in peer (pinned_cpu=%d curr_cpu=%d)\n", thread_pinned_cpu(get_current_thread()), arch_curr_cpu_num()); event_wait(&ctx->ev_req); LTRACEF("ev_req received in peer (pinned_cpu=%d curr_cpu=%d)\n", thread_pinned_cpu(get_current_thread()), arch_curr_cpu_num()); DEBUG_ASSERT(_state); thread_set_priority(state->priority_peer); switch (state->expected_state_peer) { case THREAD_RUNNING: case THREAD_READY: /* start busy loop */ done = false; do { spin_lock_irqsave(&ctx->runningstate_lock, lock_state_peer); pinned_cpu = thread_pinned_cpu(get_current_thread()); curr_cpu = thread_curr_cpu(get_current_thread()); spin_unlock_irqrestore(&ctx->runningstate_lock, lock_state_peer); if (ctx->cpu_expected > -1) { if (curr_cpu == ctx->cpu_expected) { done = true; } } else { if (pinned_cpu == -1) { done = true; } } } while (!done); LTRACEF("%s: thread %s, curr_cpu [%d] == expected_cpu [%d]!\n", __func__, ctx->thread->name, curr_cpu, ctx->cpu_expected); break; case THREAD_BLOCKED: /* go to BLOCKED state */ if (state->blockingstate_use_mutex) { mutex_acquire(&ctx->blockingstate_mutex); mutex_release(&ctx->blockingstate_mutex); } else { event_wait(&ctx->blockingstate_event); } break; case THREAD_SLEEPING: /* go to SLEEPING state for 1 sec */ thread_sleep_ns(1000000000); break; case THREAD_DEATH: /* exiting */ LTRACEF("peer thread exiting...\n"); event_signal(&ctx->ev_resp, true); return 0; default: event_signal(&ctx->ev_resp, true); return -1; } spin_lock_irqsave(&ctx->runningstate_lock, lock_state_peer); ctx->cpu_actual = thread_curr_cpu(get_current_thread()); spin_unlock_irqrestore(&ctx->runningstate_lock, lock_state_peer); if (ctx->cpu_expected > -1) { LTRACEF("PinCpuWhenThreadState%s [%s] cpu expected (%d) actual (%d)\n", thread_state_to_str(state->expected_state_peer), ctx->cpu_expected == ctx->cpu_actual ? "PASSED" : "FAILED", ctx->cpu_expected, ctx->cpu_actual); } event_signal(&ctx->ev_resp, true); thread_set_priority(HIGH_PRIORITY); } return 0; } static void pincputest_init_threads(pincputest_t* _state) { char name[24]; /* init peer thread */ const char* peer_name = "pincputest-peer-"; struct pincputest_thread_ctx_peer* ctx_peer = &_state->ctx_peer; strlcpy(name, peer_name, sizeof(name)); strlcat(name, _state->is_rt_peer ? "rt" : "std", sizeof(name)); event_init(&ctx_peer->ev_req, false, EVENT_FLAG_AUTOUNSIGNAL); event_init(&ctx_peer->ev_resp, false, EVENT_FLAG_AUTOUNSIGNAL); spin_lock_init(&ctx_peer->runningstate_lock); mutex_init(&ctx_peer->blockingstate_mutex); event_init(&ctx_peer->blockingstate_event, false, EVENT_FLAG_AUTOUNSIGNAL); ctx_peer->thread = thread_create(name, pincputest_peer_thread, (void*)_state, HIGH_PRIORITY, DEFAULT_STACK_SIZE); if (_state->is_rt_peer) { thread_set_real_time(ctx_peer->thread); } thread_set_pinned_cpu(ctx_peer->thread, 0); ctx_peer->cpu_actual = -1; /* init main thread */ struct pincputest_thread_ctx_main* ctx_main = &_state->ctx_main; const char* main_name = "pincputest-main-"; strlcpy(name, main_name, sizeof(name)); strlcat(name, _state->is_rt_main ? "rt" : "std", sizeof(name)); event_init(&ctx_main->ev_req, false, EVENT_FLAG_AUTOUNSIGNAL); event_init(&ctx_main->ev_resp, false, EVENT_FLAG_AUTOUNSIGNAL); spin_lock_init(&ctx_main->runningstate_lock); ctx_main->thread = thread_create(name, pincputest_main_thread, (void*)_state, HIGH_PRIORITY, DEFAULT_STACK_SIZE); if (_state->is_rt_main) { thread_set_real_time(ctx_main->thread); } thread_resume(ctx_peer->thread); thread_resume(ctx_main->thread); } TEST_F_SETUP(pincputest) { const void* const* params = GetParam(); // pincputest_param_to_string(params); const bool* is_rt_main = params[0]; const bool* is_rt_peer = params[1]; const bool* pinned_is_current = params[2]; const int* priority_main = params[3]; const int* priority_peer = params[4]; _state->is_rt_main = *is_rt_main; _state->is_rt_peer = *is_rt_peer; _state->pinned_is_current = *pinned_is_current; _state->priority_main = *priority_main; _state->priority_peer = *priority_peer; pincputest_init_threads(_state); } TEST_F_TEARDOWN(pincputest) { int ret; struct pincputest_thread_ctx_main* ctx_main = &_state->ctx_main; struct pincputest_thread_ctx_peer* ctx_peer = &_state->ctx_peer; _state->expected_state_peer = THREAD_DEATH; /* exiting main thread */ event_signal(&ctx_main->ev_req, true); event_wait(&ctx_main->ev_resp); thread_join(_state->ctx_main.thread, &ret, INFINITE_TIME); /* exiting peer thread */ event_signal(&ctx_peer->ev_req, true); event_wait(&ctx_peer->ev_resp); thread_join(_state->ctx_peer.thread, &ret, INFINITE_TIME); event_destroy(&ctx_main->ev_req); event_destroy(&ctx_main->ev_resp); event_destroy(&ctx_peer->ev_req); event_destroy(&ctx_peer->ev_resp); mutex_destroy(&ctx_peer->blockingstate_mutex); event_destroy(&ctx_peer->blockingstate_event); } TEST_P(pincputest, PinCpuWhenThreadStateRunning) { LTRACEF("PinCpuWhenThreadStateRunning\n"); _state->expected_state_peer = THREAD_RUNNING; _state->blockingstate_use_mutex = false; pincputest_unittest_thread(_state); ASSERT_EQ(HasFailure(), 0); test_abort:; } TEST_P(pincputest, PinCpuWhenThreadStateReady) { LTRACEF("PinCpuWhenThreadStateReady\n"); _state->expected_state_peer = THREAD_READY; _state->blockingstate_use_mutex = false; pincputest_unittest_thread(_state); ASSERT_EQ(HasFailure(), 0); test_abort:; } TEST_P(pincputest, PinCpuWhenThreadStateSleeping) { LTRACEF("PinCpuWhenThreadStateSleeping\n"); _state->expected_state_peer = THREAD_SLEEPING; _state->blockingstate_use_mutex = false; pincputest_unittest_thread(_state); ASSERT_EQ(HasFailure(), 0); test_abort:; } TEST_P(pincputest, PinCpuWhenThreadStateBlockingOnMutex) { LTRACEF("PinCpuWhenThreadStateBlockingOnMutex\n"); _state->expected_state_peer = THREAD_BLOCKED; _state->blockingstate_use_mutex = true; pincputest_unittest_thread(_state); ASSERT_EQ(HasFailure(), 0); test_abort:; } TEST_P(pincputest, PinCpuWhenThreadStateBlockingOnEvent) { LTRACEF("PinCpuWhenThreadStateBlockingOnEvent\n"); _state->expected_state_peer = THREAD_BLOCKED; _state->blockingstate_use_mutex = false; pincputest_unittest_thread(_state); ASSERT_EQ(HasFailure(), 0); test_abort:; } INSTANTIATE_TEST_SUITE_P( standard_threads, pincputest, testing_Combine(/* is_main_rt: main thread is standard */ testing_Values(0), /* is_main_rt: peer thread is standard */ testing_Values(0), /* pinned_is_current: peer thread pinned to current */ testing_Bool(), /* main thread priority */ testing_Values(HIGH_PRIORITY), /* peer thread priority */ testing_Values(HIGH_PRIORITY, HIGH_PRIORITY + 2, HIGH_PRIORITY - 2))); INSTANTIATE_TEST_SUITE_P( current_is_realtime, pincputest, testing_Combine(/* is_main_rt: main thread is standard or real-time */ testing_Values(1), /* is_main_rt: peer thread is real-time */ testing_Values(0), /* pinned_is_current: peer thread pinned to current */ testing_Values(1), // testing_Bool(), /* main thread priority */ testing_Values(HIGH_PRIORITY), /* peer thread priority */ testing_Values(HIGH_PRIORITY, HIGH_PRIORITY + 2, HIGH_PRIORITY - 2))); PORT_TEST(pincputest, "com.android.kernel.pincputest");