/*
 * Copyright (c) 2022 Intel Corporation
 *
 * SPDX-License-Identifier: Apache-2.0
 */

#include <zephyr/ztest.h>

#define HELPER_STACK_SIZE 500

/**
 * @brief Verify @a va1 and @a val2 are within @a pcnt % of each other
 */
#define TEST_WITHIN_X_PERCENT(val1, val2, pcnt)                       \
	((((val1) * 100) < ((val2) * (100 + (pcnt)))) &&              \
	 (((val1) * 100) > ((val2) * (100 - (pcnt))))) ? true : false

#if defined(CONFIG_RISCV)
#define IDLE_EVENT_STATS_PRECISION 7
#else
#define IDLE_EVENT_STATS_PRECISION 1
#endif

static struct k_thread helper_thread;
static K_THREAD_STACK_DEFINE(helper_stack, HELPER_STACK_SIZE);

static struct k_thread *main_thread;

/**
 * @brief Helper thread to test_thread_runtime_stats_get()
 */
void helper1(void *p1, void *p2, void *p3)
{
	while (1) {
	}
}

/**
 * @brief Busy wait for specified number of ticks
 */
void busy_loop(uint32_t ticks)
{
	uint32_t  tick = sys_clock_tick_get_32();

	while (sys_clock_tick_get_32() < (tick + ticks)) {
	}
}

/**
 * @brief Test the k_threads_runtime_stats_all_get() API
 *
 * 1. Create a helper thread.
 * 2. Busy loop for 2 ticks.
 *    - Idle time should not increase.
 * 3. Sleep for two ticks. Helper executes and busy loops.
 *    - Idle time should not increase
 * 4. Kill helper thread, and sleep for 2 ticks
 *    - Idle time should increase
 * 5. Busy loop for 3 ticks
 *    - Idle time should not increase
 *    - current, peak and average cycles should be different
 */
ZTEST(usage_api, test_all_stats_usage)
{
	int  priority;
	k_tid_t  tid;
	k_thread_runtime_stats_t  stats1;
	k_thread_runtime_stats_t  stats2;
	k_thread_runtime_stats_t  stats3;
	k_thread_runtime_stats_t  stats4;
	k_thread_runtime_stats_t  stats5;

	priority = k_thread_priority_get(_current);
	tid = k_thread_create(&helper_thread, helper_stack,
			      K_THREAD_STACK_SIZEOF(helper_stack),
			      helper1, NULL, NULL, NULL,
			      priority + 2, 0, K_NO_WAIT);

	k_thread_runtime_stats_all_get(&stats1);

	busy_loop(2);   /* Busy wait 2 ticks */

	k_thread_runtime_stats_all_get(&stats2);

	k_sleep(K_TICKS(2));  /* Helper runs for 2 ticks */

	k_thread_runtime_stats_all_get(&stats3);

	k_thread_abort(tid);

	k_sleep(K_TICKS(2));  /* Idle for 2 ticks */

	k_thread_runtime_stats_all_get(&stats4);

	busy_loop(3);   /* Busy wait for 3 ticks */

	k_thread_runtime_stats_all_get(&stats5);

	/*
	 * Verify that before the system idles for 2 ticks that
	 * [execution_cycles] is increasing, [total_cycles] matches
	 * [execution_cycles] and [idle_cycles] is not changing (as the
	 * system has been idle yet.
	 */

	zassert_true(stats2.execution_cycles > stats1.execution_cycles);
	zassert_true(stats3.execution_cycles > stats2.execution_cycles);
	zassert_true(stats1.execution_cycles == stats1.total_cycles);
	zassert_true(stats2.execution_cycles == stats2.total_cycles);
	zassert_true(stats3.execution_cycles == stats3.total_cycles);
#ifdef CONFIG_SCHED_THREAD_USAGE_ALL
	zassert_true(stats1.idle_cycles == stats2.idle_cycles);
	zassert_true(stats1.idle_cycles == stats3.idle_cycles);
#endif

#ifdef CONFIG_SCHED_THREAD_USAGE_ANALYSIS

	/*
	 * The analysis fields should behave as follows prior to the system
	 * going idle.
	 * 1. [current_cycles] increases.
	 * 2. [peak_cycles] matches [current_cycles].
	 * 3. [average_cycles] is 0 (because system has not gone idle yet)
	 * 4. [current_cycles] matches [execution_cycles].
	 */

	zassert_true(stats2.current_cycles > stats1.current_cycles);
	zassert_true(stats3.current_cycles > stats2.current_cycles);

	zassert_true(stats1.peak_cycles == stats1.current_cycles);
	zassert_true(stats2.peak_cycles == stats2.current_cycles);
	zassert_true(stats3.peak_cycles == stats3.current_cycles);

	zassert_true(stats1.average_cycles == 0);
	zassert_true(stats2.average_cycles == 0);
	zassert_true(stats3.average_cycles == 0);

	zassert_true(stats1.current_cycles == stats1.execution_cycles);
	zassert_true(stats2.current_cycles == stats2.execution_cycles);
	zassert_true(stats3.current_cycles == stats3.execution_cycles);
#endif

	/*
	 * Now process the statistics after the idle event.
	 *
	 * 1. [execution_cycles] continues to increase
	 * 2. [total_cycles] increases
	 * 3. [current_cycles] had a reset event but still increases
	 * 4. [peak_cycles] does not change
	 * 5. [average_cycles] increases
	 * 6. [idle_cycles] increased once.
	 */

	zassert_true(stats4.execution_cycles > stats3.execution_cycles);
	zassert_true(stats5.execution_cycles > stats4.execution_cycles);

	/*
	 * If the frequency is low enough, the [total_cycles] might not
	 * increase between sample points 3 and 4. Count this as acceptable.
	 */

	zassert_true(stats4.total_cycles >= stats3.total_cycles);
	zassert_true(stats5.total_cycles > stats4.total_cycles);

#ifdef CONFIG_SCHED_THREAD_USAGE_ANALYSIS
	zassert_true(stats4.current_cycles <= stats1.current_cycles);
	zassert_true(stats5.current_cycles > stats4.current_cycles);

	zassert_true(TEST_WITHIN_X_PERCENT(stats4.peak_cycles,
					   stats3.peak_cycles, IDLE_EVENT_STATS_PRECISION), NULL);
	zassert_true(stats4.peak_cycles == stats5.peak_cycles);

	zassert_true(stats4.average_cycles > stats3.average_cycles);
	zassert_true(stats5.average_cycles > stats4.average_cycles);
#endif

#ifdef CONFIG_SCHED_THREAD_USAGE_ALL
	zassert_true(stats4.idle_cycles > stats3.idle_cycles);
	zassert_true(stats4.idle_cycles == stats5.idle_cycles);
#endif
}

#ifdef CONFIG_SCHED_THREAD_USAGE_ANALYSIS
/**
 * @brief Test the k_thread_runtime_stats_enable/disable APIs
 */
ZTEST(usage_api, test_thread_stats_enable_disable)
{
	k_tid_t  tid;
	k_thread_runtime_stats_t  stats1;
	k_thread_runtime_stats_t  stats2;
	k_thread_runtime_stats_t  helper_stats1;
	k_thread_runtime_stats_t  helper_stats2;
	k_thread_runtime_stats_t  helper_stats3;
	int  priority;

	priority = k_thread_priority_get(_current);
	tid = k_thread_create(&helper_thread, helper_stack,
			      K_THREAD_STACK_SIZEOF(helper_stack),
			      helper1, NULL, NULL, NULL,
			      priority + 2, 0, K_NO_WAIT);

	/*
	 * Sleep to let the helper thread execute for some time before
	 * disabling the runtime stats on the helper thread.
	 */

	k_sleep(K_TICKS(5));

	k_thread_runtime_stats_get(_current, &stats1);
	k_thread_runtime_stats_get(tid, &helper_stats1);
	k_thread_runtime_stats_disable(tid);

	/*
	 * Busy wait for the remaining tick before re-enabling the thread
	 * runtime stats on the helper thread.
	 */

	busy_loop(1);

	/* Sleep for two ticks to let the helper thread execute. */

	k_sleep(K_TICKS(2));

	k_thread_runtime_stats_enable(tid);
	k_thread_runtime_stats_get(_current, &stats2);
	k_thread_runtime_stats_get(tid, &helper_stats2);

	/* Sleep for two ticks to let the helper thread execute again. */

	k_sleep(K_TICKS(2));

	k_thread_runtime_stats_get(tid, &helper_stats3);

	/*
	 * Verify that the between sample sets 1 and 2 that additional stats
	 * were not gathered for the helper thread, but were gathered for the
	 * main current thread.
	 */

	zassert_true(helper_stats1.execution_cycles ==
		     helper_stats2.execution_cycles, NULL);
	zassert_true(stats1.execution_cycles < stats2.execution_cycles);

	/*
	 * Verify that between sample sets 2 and 3 that additional stats were
	 * gathered for the helper thread.
	 */

	zassert_true(helper_stats2.execution_cycles <
		     helper_stats3.execution_cycles, NULL);

	k_thread_abort(tid);
}
#else
ZTEST(usage_api, test_thread_stats_enable_disable)
{
}
#endif

#ifdef CONFIG_SCHED_THREAD_USAGE_ALL
/**
 * @brief Test the k_sys_runtime_stats_enable/disable APIs
 */
ZTEST(usage_api, test_sys_stats_enable_disable)
{
	k_thread_runtime_stats_t  sys_stats1;
	k_thread_runtime_stats_t  sys_stats2;
	k_thread_runtime_stats_t  sys_stats3;
	k_thread_runtime_stats_t  thread_stats1;
	k_thread_runtime_stats_t  thread_stats2;
	k_thread_runtime_stats_t  thread_stats3;

	/*
	 * Disable system runtime stats gathering.
	 * This should not impact thread runtime stats gathering.
	 */

	k_sys_runtime_stats_disable();

	k_thread_runtime_stats_get(_current, &thread_stats1);
	k_thread_runtime_stats_all_get(&sys_stats1);

	busy_loop(2);

	k_thread_runtime_stats_get(_current, &thread_stats2);
	k_thread_runtime_stats_all_get(&sys_stats2);

	/*
	 * Enable system runtime stats gathering.
	 * This should not impact thread runtime stats gathering.
	 */

	k_sys_runtime_stats_enable();

	busy_loop(2);

	k_thread_runtime_stats_get(_current, &thread_stats3);
	k_thread_runtime_stats_all_get(&sys_stats3);

	/*
	 * There ought to be no differences between sys_stat1 and sys_stat2.
	 * Although a memory compare of the two structures would be sufficient,
	 * each individual field is being tested in case to more easily
	 * isolate the cause of any error.
	 */

	zassert_true(sys_stats1.execution_cycles == sys_stats2.execution_cycles,
		     NULL);
	zassert_true(sys_stats1.total_cycles == sys_stats2.total_cycles);

#ifdef CONFIG_SCHED_THREAD_USAGE_ANALYSIS
	zassert_true(sys_stats1.current_cycles == sys_stats2.current_cycles,
		     NULL);
	zassert_true(sys_stats1.peak_cycles == sys_stats2.peak_cycles);
	zassert_true(sys_stats1.average_cycles == sys_stats2.average_cycles,
		     NULL);
#endif

#ifdef CONFIG_SCHED_THREAD_USAGE_ALL
	zassert_true(sys_stats1.idle_cycles == sys_stats2.idle_cycles);
#endif

	/*
	 * As only system stats have been disabled, thread stats should be
	 * unaffected. To simplify things, just check [execution_cycles] and
	 * [current_cycles] (if enabled).
	 */

	zassert_true(thread_stats1.execution_cycles <
		     thread_stats2.execution_cycles, NULL);

#ifdef CONFIG_SCHED_THREAD_USAGE_ANALYSIS
	zassert_true(thread_stats1.current_cycles <
		     thread_stats2.current_cycles, NULL);
#endif

	/*
	 * Now verify that the enabling of system runtime stats gathering
	 * has resulted in the gathering of system runtime stats. Again,
	 * thread runtime stats gathering should be unaffected.
	 */

	zassert_true(sys_stats2.execution_cycles < sys_stats3.execution_cycles,
		     NULL);
	zassert_true(sys_stats2.total_cycles < sys_stats3.total_cycles);

#ifdef CONFIG_SCHED_THREAD_USAGE_ANALYSIS

	/*
	 * As enabling reset [current_cycles], it is not easy to predict
	 * what its value should be. For now, settle for ensuring that it
	 * is different and not zero.
	 */

	zassert_true(sys_stats2.current_cycles != sys_stats3.current_cycles,
		     NULL);
	zassert_true(sys_stats2.current_cycles != 0);
	zassert_true(sys_stats2.peak_cycles == sys_stats3.peak_cycles);
	zassert_true(sys_stats2.average_cycles > sys_stats3.average_cycles,
		     NULL);
#endif

#ifdef CONFIG_SCHED_THREAD_USAGE_ALL
	zassert_true(sys_stats2.idle_cycles == sys_stats3.idle_cycles);
#endif
}
#else
ZTEST(usage_api, test_sys_stats_enable_disable)
{
}
#endif

/**
 * @brief Timer handler to resume the main thread
 */
void resume_main(struct k_timer *timer)
{
	k_thread_resume(main_thread);
}

/**
 * @brief Test the k_thread_runtime_stats_get() API
 *
 * This routine tests the k_thread_runtime_stats_get() routine. It verifies
 * that the contents of the fields guarded by CONFIG_SCHED_THREAD_USAGE
 * are correct.
 */
ZTEST(usage_api, test_thread_stats_usage)
{
	k_tid_t  tid;
	int  priority;
	int  status;
	struct k_timer   timer;
	k_thread_runtime_stats_t  stats1;
	k_thread_runtime_stats_t  stats2;
	k_thread_runtime_stats_t  stats3;

	priority = k_thread_priority_get(_current);

	/*
	 * Verify that k_thread_runtime_stats_get() returns the expected
	 * values for error cases.
	 */

	status = k_thread_runtime_stats_get(NULL, &stats1);
	zassert_true(status == -EINVAL);

	status = k_thread_runtime_stats_get(_current, NULL);
	zassert_true(status == -EINVAL);

	/* Align to the next tick */

	k_sleep(K_TICKS(1));

	/* Create a low priority helper thread to start in 1 tick. */

	tid = k_thread_create(&helper_thread, helper_stack,
			      K_THREAD_STACK_SIZEOF(helper_stack),
			      helper1, NULL, NULL, NULL,
			      priority + 2, 0, K_TICKS(1));

	main_thread = _current;
	k_timer_init(&timer, resume_main, NULL);
	k_timer_start(&timer, K_TICKS(1), K_TICKS(10));

	/* Verify thread creation succeeded */

	zassert_true(tid == &helper_thread);

	/* Get a valid set of thread runtime stats */

	status = k_thread_runtime_stats_get(tid, &stats1);
	zassert_true(status == 0);

	/*
	 * Suspend main thread. Timer will wake it 1 tick to sample
	 * the helper threads runtime stats.
	 */

	k_thread_suspend(_current);

	/*
	 * T = 1.
	 * Timer woke the main thread. Sample runtime stats for helper thread
	 * before suspending.
	 */

	k_thread_runtime_stats_get(tid, &stats1);
	k_thread_suspend(_current);

	/*
	 * T = 11.
	 * Timer woke the main thread. Suspend main thread again.
	 */

	k_thread_suspend(_current);

	/*
	 * T = 21.
	 * Timer woke the main thread. Sample runtime stats for helper thread
	 * before suspending.
	 */

	k_thread_runtime_stats_get(tid, &stats2);
	k_thread_suspend(_current);

	/*
	 * T = 31.
	 * Timer woke the main thread. Sample runtime stats for helper thread
	 * and stop the timer.
	 */

	k_thread_runtime_stats_get(tid, &stats3);
	k_timer_stop(&timer);

#ifdef CONFIG_SCHED_THREAD_USAGE_ANALYSIS
	k_thread_runtime_stats_t  stats4;
	k_thread_runtime_stats_t  stats5;

	/*
	 * Sleep for 20 ticks, and then 1 tick. This will allow the helper
	 * thread to have two different scheduled execution windows.
	 */

	k_sleep(K_TICKS(20));
	k_thread_runtime_stats_get(tid, &stats4);

	k_sleep(K_TICKS(1));
	k_thread_runtime_stats_get(tid, &stats5);
#endif

	/* Verify execution_cycles are identical to total_cycles */

	zassert_true(stats1.execution_cycles == stats1.total_cycles);
	zassert_true(stats2.execution_cycles == stats2.total_cycles);

#ifdef CONFIG_SCHED_THREAD_USAGE_ALL
	zassert_true(stats3.idle_cycles == 0);
#endif

	/*
	 * Verify that the time for which the helper thread executed between
	 * the first and second samplings is more than that between the
	 * second and third.
	 */

	uint64_t  diff12;
	uint64_t  diff23;

	diff12 = stats2.execution_cycles - stats1.execution_cycles;
	diff23 = stats3.execution_cycles - stats2.execution_cycles;

	zassert_true(diff12 > diff23);

#ifdef CONFIG_SCHED_THREAD_USAGE_ANALYSIS

	/* Verify that [current_cycles] change as expected. */

	zassert_true(stats4.current_cycles >= stats5.current_cycles);
	zassert_true(stats4.current_cycles > stats3.current_cycles);
	zassert_true(stats5.current_cycles < stats3.current_cycles);

	/* Verify that [peak_cycles] change as expected */

	zassert_true(stats4.peak_cycles > stats2.peak_cycles);
	zassert_true(stats4.peak_cycles == stats5.peak_cycles);
	zassert_true(stats4.peak_cycles == stats4.current_cycles);

	/* Verify that [average_cycles] change as expected */

	zassert_true(stats4.average_cycles > stats3.average_cycles);
	zassert_true(stats4.average_cycles > stats5.average_cycles);
	zassert_true(stats5.average_cycles >= stats3.average_cycles);
#endif

	/* Abort the helper thread */

	k_thread_abort(tid);
}

ZTEST_SUITE(usage_api, NULL, NULL,
		ztest_simple_1cpu_before, ztest_simple_1cpu_after, NULL);