path: root/drivers/gpu/drm/scheduler/tests/tests_scheduler.c

// SPDX-License-Identifier: GPL-2.0
/* Copyright (c) 2025 Valve Corporation */

#include <linux/delay.h>
#include <linux/kthread.h>
#include <linux/ktime.h>
#include <linux/math64.h>

#include "sched_tests.h"

/*
 * DRM scheduler tests exercise load balancing decisions ie. entity selection
 * logic.
 */

static int drm_sched_scheduler_init(struct kunit *test)
{
	struct drm_mock_scheduler *sched;

	sched = drm_mock_sched_new(test, MAX_SCHEDULE_TIMEOUT);
	sched->base.credit_limit = 1;

	test->priv = sched;

	return 0;
}

static int drm_sched_scheduler_init2(struct kunit *test)
{
	struct drm_mock_scheduler *sched;

	sched = drm_mock_sched_new(test, MAX_SCHEDULE_TIMEOUT);
	sched->base.credit_limit = 2;

	test->priv = sched;

	return 0;
}

static void drm_sched_scheduler_exit(struct kunit *test)
{
	struct drm_mock_scheduler *sched = test->priv;

	drm_mock_sched_fini(sched);
}

static void drm_sched_scheduler_queue_overhead(struct kunit *test)
{
	struct drm_mock_scheduler *sched = test->priv;
	struct drm_mock_sched_entity *entity;
	const unsigned int job_us = 1000;
	const unsigned int jobs = 1000;
	const unsigned int total_us = jobs * job_us;
	struct drm_mock_sched_job *job, *first;
	ktime_t start, end;
	bool done;
	int i;

	/*
	 * Deep queue job at a time processing (single credit).
	 *
	 * This measures the overhead of picking and processing a job at a time
	 * by comparing the ideal total "GPU" time of all submitted jobs versus
	 * the time actually taken.
	 */

	KUNIT_ASSERT_EQ(test, sched->base.credit_limit, 1);

	entity = drm_mock_sched_entity_new(test,
					   DRM_SCHED_PRIORITY_NORMAL,
					   sched);

	for (i = 0; i <= jobs; i++) {
		job = drm_mock_sched_job_new(test, entity);
		if (i == 0)
			first = job; /* Extra first job blocks the queue */
		else
			drm_mock_sched_job_set_duration_us(job, job_us);
		drm_mock_sched_job_submit(job);
	}

	done = drm_mock_sched_job_wait_scheduled(first, HZ);
	KUNIT_ASSERT_TRUE(test, done);

	start = ktime_get();
	i = drm_mock_sched_advance(sched, 1); /* Release the queue */
	KUNIT_ASSERT_EQ(test, i, 1);

	/* Wait with a safe margin to avoid every failing. */
	done = drm_mock_sched_job_wait_finished(job,
						usecs_to_jiffies(total_us) * 5);
	end = ktime_get();
	KUNIT_ASSERT_TRUE(test, done);

	pr_info("Expected %uus, actual %lldus\n",
		total_us,
		ktime_to_us(ktime_sub(end, start)));

	drm_mock_sched_entity_free(entity);
}

static void drm_sched_scheduler_ping_pong(struct kunit *test)
{
	struct drm_mock_sched_job *job, *first, *prev = NULL;
	struct drm_mock_scheduler *sched = test->priv;
	struct drm_mock_sched_entity *entity[2];
	const unsigned int job_us = 1000;
	const unsigned int jobs = 1000;
	const unsigned int total_us = jobs * job_us;
	ktime_t start, end;
	bool done;
	int i;

	/*
	 * Two entitites in inter-dependency chain.
	 *
	 * This measures the overhead of picking and processing a job at a time,
	 * where each job depends on the previous one from the diffferent
	 * entity, by comparing the ideal total "GPU" time of all submitted jobs
	 * versus the time actually taken.
	 */

	KUNIT_ASSERT_EQ(test, sched->base.credit_limit, 1);

	for (i = 0; i < ARRAY_SIZE(entity); i++)
		entity[i] = drm_mock_sched_entity_new(test,
						      DRM_SCHED_PRIORITY_NORMAL,
						      sched);

	for (i = 0; i <= jobs; i++) {
		job = drm_mock_sched_job_new(test, entity[i & 1]);
		if (i == 0)
			first = job; /* Extra first job blocks the queue */
		else
			drm_mock_sched_job_set_duration_us(job, job_us);
		if (prev)
			drm_sched_job_add_dependency(&job->base,
						     dma_fence_get(&prev->base.s_fence->finished));
		drm_mock_sched_job_submit(job);
		prev = job;
	}

	done = drm_mock_sched_job_wait_scheduled(first, HZ);
	KUNIT_ASSERT_TRUE(test, done);

	start = ktime_get();
	i = drm_mock_sched_advance(sched, 1); /* Release the queue */
	KUNIT_ASSERT_EQ(test, i, 1);

	/* Wait with a safe margin to avoid every failing. */
	done = drm_mock_sched_job_wait_finished(job,
						usecs_to_jiffies(total_us) * 5);
	end = ktime_get();
	KUNIT_ASSERT_TRUE(test, done);

	pr_info("Expected %uus, actual %lldus\n",
		total_us,
		ktime_to_us(ktime_sub(end, start)));

	for (i = 0; i < ARRAY_SIZE(entity); i++)
		drm_mock_sched_entity_free(entity[i]);
}

static struct kunit_case drm_sched_scheduler_overhead_tests[] = {
	KUNIT_CASE_SLOW(drm_sched_scheduler_queue_overhead),
	KUNIT_CASE_SLOW(drm_sched_scheduler_ping_pong),
	{}
};

static struct kunit_suite drm_sched_scheduler_overhead = {
	.name = "drm_sched_scheduler_overhead_tests",
	.init = drm_sched_scheduler_init,
	.exit = drm_sched_scheduler_exit,
	.test_cases = drm_sched_scheduler_overhead_tests,
};

/*
 * struct drm_sched_client_params - describe a workload emitted from a client
 *
 * A simulated client will create an entity with a scheduling @priority and emit
 * jobs in a loop where each iteration will consist of:
 *
 * 1. Submit @job_cnt jobs, each with a set duration of @job_us.
 * 2. If @sync is true wait for last submitted job to finish.
 * 3. Sleep for @wait_us micro-seconds.
 * 4. Repeat.
 */
struct drm_sched_client_params {
	enum drm_sched_priority priority;
	unsigned int job_cnt;
	unsigned int job_us;
	bool sync;
	unsigned int wait_us;
};

struct drm_sched_test_params {
	const char *description;
	unsigned int num_clients;
	struct drm_sched_client_params client[2];
};

static const struct drm_sched_test_params drm_sched_cases[] = {
	{
		.description = "Normal priority and normal priority",
		.client[0] = {
			.priority = DRM_SCHED_PRIORITY_NORMAL,
			.job_cnt = 1,
			.job_us = 8000,
			.wait_us = 0,
			.sync = false,
		},
		.client[1] = {
			.priority = DRM_SCHED_PRIORITY_NORMAL,
			.job_cnt = 1,
			.job_us = 8000,
			.wait_us = 0,
			.sync = false,
		},
	},
	{
		.description = "Normal priority and low priority",
		.client[0] = {
			.priority = DRM_SCHED_PRIORITY_NORMAL,
			.job_cnt = 1,
			.job_us = 8000,
			.wait_us = 0,
			.sync = false,
		},
		.client[1] = {
			.priority = DRM_SCHED_PRIORITY_LOW,
			.job_cnt = 1,
			.job_us = 8000,
			.wait_us = 0,
			.sync = false,
		},
	},
	{
		.description = "High priority and normal priority",
		.client[0] = {
			.priority = DRM_SCHED_PRIORITY_HIGH,
			.job_cnt = 1,
			.job_us = 8000,
			.wait_us = 0,
			.sync = false,
		},
		.client[1] = {
			.priority = DRM_SCHED_PRIORITY_NORMAL,
			.job_cnt = 1,
			.job_us = 8000,
			.wait_us = 0,
			.sync = false,
		},
	},
	{
		.description = "High priority and low priority",
		.client[0] = {
			.priority = DRM_SCHED_PRIORITY_HIGH,
			.job_cnt = 1,
			.job_us = 8000,
			.wait_us = 0,
			.sync = false,
		},
		.client[1] = {
			.priority = DRM_SCHED_PRIORITY_LOW,
			.job_cnt = 1,
			.job_us = 8000,
			.wait_us = 0,
			.sync = false,
		},
	},
	{
		.description = "50% and 50%",
		.client[0] = {
			.priority = DRM_SCHED_PRIORITY_NORMAL,
			.job_cnt = 1,
			.job_us = 1500,
			.wait_us = 1500,
			.sync = true,
		},
		.client[1] = {
			.priority = DRM_SCHED_PRIORITY_NORMAL,
			.job_cnt = 1,
			.job_us = 2500,
			.wait_us = 2500,
			.sync = true,
		},
	},
	{
		.description = "50% and 50% low priority",
		.client[0] = {
			.priority = DRM_SCHED_PRIORITY_NORMAL,
			.job_cnt = 1,
			.job_us = 1500,
			.wait_us = 1500,
			.sync = true,
		},
		.client[1] = {
			.priority = DRM_SCHED_PRIORITY_LOW,
			.job_cnt = 1,
			.job_us = 2500,
			.wait_us = 2500,
			.sync = true,
		},
	},
	{
		.description = "50% high priority and 50%",
		.client[0] = {
			.priority = DRM_SCHED_PRIORITY_HIGH,
			.job_cnt = 1,
			.job_us = 1500,
			.wait_us = 1500,
			.sync = true,
		},
		.client[1] = {
			.priority = DRM_SCHED_PRIORITY_NORMAL,
			.job_cnt = 1,
			.job_us = 2500,
			.wait_us = 2500,
			.sync = true,
		},
	},
	{
		.description = "Low priority hog and interactive client",
		.client[0] = {
			.priority = DRM_SCHED_PRIORITY_LOW,
			.job_cnt = 3,
			.job_us = 2500,
			.wait_us = 500,
			.sync = false,
		},
		.client[1] = {
			.priority = DRM_SCHED_PRIORITY_NORMAL,
			.job_cnt = 1,
			.job_us = 500,
			.wait_us = 10000,
			.sync = true,
		},
	},
	{
		.description = "Heavy rendering and interactive client",
		.client[0] = {
			.priority = DRM_SCHED_PRIORITY_NORMAL,
			.job_cnt = 3,
			.job_us = 2500,
			.wait_us = 2500,
			.sync = true,
		},
		.client[1] = {
			.priority = DRM_SCHED_PRIORITY_NORMAL,
			.job_cnt = 1,
			.job_us = 1000,
			.wait_us = 9000,
			.sync = true,
		},
	},
	{
		.description = "Very heavy rendering and interactive client",
		.client[0] = {
			.priority = DRM_SCHED_PRIORITY_NORMAL,
			.job_cnt = 4,
			.job_us = 50000,
			.wait_us = 1,
			.sync = true,
		},
		.client[1] = {
			.priority = DRM_SCHED_PRIORITY_NORMAL,
			.job_cnt = 1,
			.job_us = 1000,
			.wait_us = 9000,
			.sync = true,
		},
	},
};

static void
drm_sched_desc(const struct drm_sched_test_params *params, char *desc)
{
	strscpy(desc, params->description, KUNIT_PARAM_DESC_SIZE);
}

KUNIT_ARRAY_PARAM(drm_sched_scheduler_two_clients,
		  drm_sched_cases,
		  drm_sched_desc);

/*
 * struct test_client_stats - track client stats
 *
 * For each client executing a simulated workload we track some timings for
 * which we are interested in the minimum of all iterations (@min_us), maximum
 * (@max_us) and the overall total for all iterations (@tot_us).
 */
struct test_client_stats {
	unsigned int min_us;
	unsigned int max_us;
	unsigned long tot_us;
};

/*
 * struct test_client - a simulated userspace client submitting scheduler work
 *
 * Each client executing a simulated workload is represented by one of these.
 *
 * Each of them instantiates a scheduling @entity and executes a workloads as
 * defined in @params. Based on those @params the theoretical execution time of
 * the client is calculated as @ideal_duration, while the actual wall time is
 * tracked in @duration (calculated based on the @start and @end client time-
 * stamps).
 *
 * Numerical @id is assigned to each for logging purposes.
 *
 * @worker and @work are used to provide an independent execution context from
 * which scheduler jobs are submitted.
 *
 * During execution statistics on how long it took to submit and execute one
 * iteration (whether or not synchronous) is kept in @cycle_time, while
 * @latency_time tracks the @cycle_time minus the ideal duration of the one
 * cycle.
 *
 * Once the client has completed the set number of iterations it will write the
 * completion status into @done.
 */
struct test_client {
	struct kunit	*test; /* Backpointer to the kunit test. */

	struct drm_mock_sched_entity	*entity;
	struct kthread_worker		*worker;
	struct kthread_work		work;

	struct drm_sched_client_params	params;

	unsigned int	id;
	ktime_t		duration;
	ktime_t		ideal_duration;
	unsigned int	cycles;
	unsigned int	cycle;
	ktime_t		start;
	ktime_t		end;
	bool		done;

	struct test_client_stats	cycle_time;
	struct test_client_stats	latency_time;
};

static void
update_stats(struct test_client_stats *stats, unsigned int us)
{
	if (us > stats->max_us)
		stats->max_us = us;
	if (us < stats->min_us)
		stats->min_us = us;
	stats->tot_us += us;
}

static unsigned int
get_stats_avg(struct test_client_stats *stats, unsigned int cycles)
{
	return div_u64(stats->tot_us, cycles);
}

static void drm_sched_client_work(struct kthread_work *work)
{
	struct test_client *client = container_of(work, typeof(*client), work);
	const long sync_wait = MAX_SCHEDULE_TIMEOUT;
	unsigned int cycle, work_us, period_us;
	struct drm_mock_sched_job *job = NULL;

	work_us = client->params.job_cnt * client->params.job_us;
	period_us = work_us + client->params.wait_us;
	client->cycles =
		DIV_ROUND_UP((unsigned int)ktime_to_us(client->duration),
			     period_us);
	client->ideal_duration = us_to_ktime(client->cycles * period_us);

	client->start = ktime_get();

	for (cycle = 0; cycle < client->cycles; cycle++) {
		ktime_t cycle_time;
		unsigned int batch;
		unsigned long us;

		if (READ_ONCE(client->done))
			break;

		cycle_time = ktime_get();
		for (batch = 0; batch < client->params.job_cnt; batch++) {
			job = drm_mock_sched_job_new(client->test,
						     client->entity);
			drm_mock_sched_job_set_duration_us(job,
							   client->params.job_us);
			drm_mock_sched_job_submit(job);
		}

		if (client->params.sync)
			drm_mock_sched_job_wait_finished(job, sync_wait);

		cycle_time = ktime_sub(ktime_get(), cycle_time);
		us = ktime_to_us(cycle_time);
		update_stats(&client->cycle_time, us);
		if (ktime_to_us(cycle_time) >= (long)work_us)
			us = ktime_to_us(cycle_time) - work_us;
		else if (WARN_ON_ONCE(client->params.sync)) /* GPU job took less than expected. */
			us = 0;
		update_stats(&client->latency_time, us);
		WRITE_ONCE(client->cycle, cycle);

		if (READ_ONCE(client->done))
			break;

		if (client->params.wait_us)
			fsleep(client->params.wait_us);
		else if (!client->params.sync)
			cond_resched(); /* Do not hog the CPU if fully async. */
	}

	client->done = drm_mock_sched_job_wait_finished(job, sync_wait);
	client->end = ktime_get();
}

static const char *prio_str(enum drm_sched_priority prio)
{
	switch (prio) {
	case DRM_SCHED_PRIORITY_KERNEL:
		return "kernel";
	case DRM_SCHED_PRIORITY_LOW:
		return "low";
	case DRM_SCHED_PRIORITY_NORMAL:
		return "normal";
	case DRM_SCHED_PRIORITY_HIGH:
		return "high";
	default:
		return "???";
	}
}

static bool client_done(struct test_client *client)
{
	return READ_ONCE(client->done); /* READ_ONCE to document lockless read from a loop. */
}

static void drm_sched_scheduler_two_clients_test(struct kunit *test)
{
	const struct drm_sched_test_params *params = test->param_value;
	struct drm_mock_scheduler *sched = test->priv;
	struct test_client client[2] = { };
	unsigned int prev_cycle[2] = { };
	unsigned int i, j;
	ktime_t start;

	/*
	 * Same job stream from two clients.
	 */

	for (i = 0; i < ARRAY_SIZE(client); i++)
		client[i].entity =
			drm_mock_sched_entity_new(test,
						  params->client[i].priority,
						  sched);

	for (i = 0; i < ARRAY_SIZE(client); i++) {
		client[i].test = test;
		client[i].id = i;
		client[i].duration = ms_to_ktime(1000);
		client[i].params = params->client[i];
		client[i].cycle_time.min_us = ~0U;
		client[i].latency_time.min_us = ~0U;
		client[i].worker =
			kthread_create_worker(0, "%s-%u", __func__, i);
		if (IS_ERR(client[i].worker)) {
			for (j = 0; j < i; j++)
				kthread_destroy_worker(client[j].worker);
			KUNIT_FAIL(test, "Failed to create worker!\n");
		}

		kthread_init_work(&client[i].work, drm_sched_client_work);
	}

	for (i = 0; i < ARRAY_SIZE(client); i++)
		kthread_queue_work(client[i].worker, &client[i].work);

	/*
	 * The clients (workers) can be a mix of async (deep submission queue),
	 * sync (one job at a time), or something in between. Therefore it is
	 * difficult to display a single metric representing their progress.
	 *
	 * Each struct drm_sched_client_params describes the actual submission
	 * pattern which happens in the following steps:
	 *  1. Submit N jobs
	 *  2. Wait for last submitted job to finish
	 *  3. Sleep for U micro-seconds
	 *  4. Goto 1. for C cycles
	 *
	 * Where number of cycles is calculated to match the target client
	 * duration from the respective struct drm_sched_test_params.
	 *
	 * To asses scheduling behaviour what we output for both clients is:
	 *  - pct: Percentage progress of the jobs submitted
	 *  - cps: "Cycles" per second (where one cycle is one complete
	 *         iteration from the above)
	 *  -  qd: Number of outstanding jobs in the client/entity
	 */

	pr_info(" [pct] - Job sumission progress\n"
" [cps] - Cycles per second\n"
"  [qd] - Number of outstanding jobs in the client/entity\n");
	pr_info("%s:\n\t            pct1 cps1 qd1;  pct2 cps2 qd2\n",
		params->description);
	start = ktime_get();
	while (!client_done(&client[0]) || !client_done(&client[1])) {
		const unsigned int period_ms = 100;
		const unsigned int frequency = 1000 / period_ms;
		unsigned int pct[2], qd[2], cycle[2], cps[2];

		for (i = 0; i < ARRAY_SIZE(client); i++) {
			qd[i] = spsc_queue_count(&client[i].entity->base.job_queue);
			cycle[i] = READ_ONCE(client[i].cycle);
			cps[i] = DIV_ROUND_UP(100 * frequency *
					      (cycle[i] - prev_cycle[i]),
					      100);
			if (client[i].cycles)
				pct[i] = DIV_ROUND_UP(100 * (1 + cycle[i]),
						      client[i].cycles);
			else
				pct[i] = 0;
			prev_cycle[i] = cycle[i];
		}

		if (client_done(&client[0]))
			pr_info("\t+%6lldms:               ; %3u %5u %4u\n",
				ktime_to_ms(ktime_sub(ktime_get(), start)),
				pct[1], cps[1], qd[1]);
		else if (client_done(&client[1]))
			pr_info("\t+%6lldms: %3u %5u %4u;\n",
				ktime_to_ms(ktime_sub(ktime_get(), start)),
				pct[0], cps[0], qd[0]);
		else
			pr_info("\t+%6lldms: %3u %5u %4u; %3u %5u %4u\n",
				ktime_to_ms(ktime_sub(ktime_get(), start)),
				pct[0], cps[0], qd[0],
				pct[1], cps[1], qd[1]);

		msleep(period_ms);
	}

	for (i = 0; i < ARRAY_SIZE(client); i++) {
		kthread_flush_work(&client[i].work);
		kthread_destroy_worker(client[i].worker);
	}

	for (i = 0; i < ARRAY_SIZE(client); i++)
		KUNIT_ASSERT_TRUE(test, client[i].done);

	for (i = 0; i < ARRAY_SIZE(client); i++) {
		pr_info("    %u: prio=%s sync=%u elapsed_ms=%lldms (ideal_ms=%lldms) cycle_time(min,avg,max)=%u,%u,%u us latency_time(min,avg,max)=%u,%u,%u us",
			i,
			prio_str(params->client[i].priority),
			params->client[i].sync,
			ktime_to_ms(ktime_sub(client[i].end, client[i].start)),
			ktime_to_ms(client[i].ideal_duration),
			client[i].cycle_time.min_us,
			get_stats_avg(&client[i].cycle_time, client[i].cycles),
			client[i].cycle_time.max_us,
			client[i].latency_time.min_us,
			get_stats_avg(&client[i].latency_time, client[i].cycles),
			client[i].latency_time.max_us);
		drm_mock_sched_entity_free(client[i].entity);
	}
}

static struct kunit_case drm_sched_scheduler_two_clients_tests[] = {
	KUNIT_CASE_PARAM_ATTR(drm_sched_scheduler_two_clients_test,
			      drm_sched_scheduler_two_clients_gen_params,
			      { .speed = KUNIT_SPEED_SLOW }),
	{}
};

static struct kunit_suite drm_sched_scheduler_two_clients1 = {
	.name = "drm_sched_scheduler_two_clients_one_credit_tests",
	.init = drm_sched_scheduler_init,
	.exit = drm_sched_scheduler_exit,
	.test_cases = drm_sched_scheduler_two_clients_tests,
};

static struct kunit_suite drm_sched_scheduler_two_clients2 = {
	.name = "drm_sched_scheduler_two_clients_two_credits_tests",
	.init = drm_sched_scheduler_init2,
	.exit = drm_sched_scheduler_exit,
	.test_cases = drm_sched_scheduler_two_clients_tests,
};

static const struct drm_sched_test_params drm_sched_many_cases[] = {
	{
		.description = "2 clients",
		.num_clients = 2,
		.client[0] = {
			.priority = DRM_SCHED_PRIORITY_NORMAL,
			.job_cnt = 4,
			.job_us = 1000,
			.wait_us = 0,
			.sync = true,
		},
	},
	{
		.description = "3 clients",
		.num_clients = 3,
		.client[0] = {
			.priority = DRM_SCHED_PRIORITY_NORMAL,
			.job_cnt = 4,
			.job_us = 1000,
			.wait_us = 0,
			.sync = true,
		},
	},
	{
		.description = "7 clients",
		.num_clients = 7,
		.client[0] = {
			.priority = DRM_SCHED_PRIORITY_NORMAL,
			.job_cnt = 4,
			.job_us = 1000,
			.wait_us = 0,
			.sync = true,
		},
	},
	{
		.description = "13 clients",
		.num_clients = 13,
		.client[0] = {
			.priority = DRM_SCHED_PRIORITY_NORMAL,
			.job_cnt = 4,
			.job_us = 1000,
			.wait_us = 0,
			.sync = true,
		},
	},
	{
		.description = "31 clients",
		.num_clients = 31,
		.client[0] = {
			.priority = DRM_SCHED_PRIORITY_NORMAL,
			.job_cnt = 2,
			.job_us = 1000,
			.wait_us = 0,
			.sync = true,
		},
	},
};

KUNIT_ARRAY_PARAM(drm_sched_scheduler_many_clients,
		  drm_sched_many_cases,
		  drm_sched_desc);

static void drm_sched_scheduler_many_clients_test(struct kunit *test)
{
	const struct drm_sched_test_params *params = test->param_value;
	struct drm_mock_scheduler *sched = test->priv;
	const unsigned int clients = params->num_clients;
	unsigned int i, j, delta_total = 0, loops = 0;
	struct test_client *client;
	unsigned int *prev_cycle;
	ktime_t start;
	char *buf;

	/*
	 * Many clients with deep-ish async queues.
	 */

	buf = kunit_kmalloc(test, PAGE_SIZE, GFP_KERNEL);
	KUNIT_ASSERT_NOT_NULL(test, buf);
	client = kunit_kcalloc(test, clients, sizeof(*client), GFP_KERNEL);
	KUNIT_ASSERT_NOT_NULL(test, client);
	prev_cycle = kunit_kcalloc(test, clients, sizeof(*prev_cycle),
				   GFP_KERNEL);
	KUNIT_ASSERT_NOT_NULL(test, prev_cycle);

	for (i = 0; i < clients; i++)
		client[i].entity =
			drm_mock_sched_entity_new(test,
						  DRM_SCHED_PRIORITY_NORMAL,
						  sched);

	for (i = 0; i < clients; i++) {
		client[i].test = test;
		client[i].id = i;
		client[i].params = params->client[0];
		client[i].duration = ms_to_ktime(1000 / clients);
		client[i].cycle_time.min_us = ~0U;
		client[i].latency_time.min_us = ~0U;
		client[i].worker =
			kthread_create_worker(0, "%s-%u", __func__, i);
		if (IS_ERR(client[i].worker)) {
			for (j = 0; j < i; j++)
				kthread_destroy_worker(client[j].worker);
			KUNIT_FAIL(test, "Failed to create worker!\n");
		}

		kthread_init_work(&client[i].work, drm_sched_client_work);
	}

	for (i = 0; i < clients; i++)
		kthread_queue_work(client[i].worker, &client[i].work);

	start = ktime_get();
	pr_info("%u clients:\n\tt\t\tcycle:\t  min    avg    max : ...\n", clients);
	for (;;) {
		unsigned int min = ~0;
		unsigned int max = 0;
		unsigned int total = 0;
		bool done = true;
		char pbuf[16];

		memset(buf, 0, PAGE_SIZE);
		for (i = 0; i < clients; i++) {
			unsigned int cycle, cycles;

			/* Read current progress from the threaded worker. */
			cycle = READ_ONCE(client[i].cycle);
			cycles = READ_ONCE(client[i].cycles);

			snprintf(pbuf, sizeof(pbuf), " %3d", cycle);
			strncat(buf, pbuf, PAGE_SIZE);

			total += cycle;
			if (cycle < min)
				min = cycle;
			if (cycle > max)
				max = cycle;

			if (!min || (cycle + 1) < cycles)
				done = false;
		}

		loops++;
		delta_total += max - min;

		pr_info("\t+%6lldms\t\t  %3u  %3u  %3u :%s\n",
			ktime_to_ms(ktime_sub(ktime_get(), start)),
			min, DIV_ROUND_UP(total, clients), max, buf);

		if (done)
			break;

		msleep(100);
	}

	pr_info("    avg_max_min_delta(x100)=%u\n",
		loops ? DIV_ROUND_UP(delta_total * 100, loops) : 0);

	for (i = 0; i < clients; i++) {
		kthread_flush_work(&client[i].work);
		kthread_destroy_worker(client[i].worker);
	}

	for (i = 0; i < clients; i++)
		drm_mock_sched_entity_free(client[i].entity);
}

static struct kunit_case drm_sched_scheduler_many_clients_tests[] = {
	KUNIT_CASE_PARAM_ATTR(drm_sched_scheduler_many_clients_test,
			      drm_sched_scheduler_many_clients_gen_params,
			      { .speed = KUNIT_SPEED_SLOW }),
	{}
};

static struct kunit_suite drm_sched_scheduler_many_clients = {
	.name = "drm_sched_scheduler_many_clients_tests",
	.init = drm_sched_scheduler_init2,
	.exit = drm_sched_scheduler_exit,
	.test_cases = drm_sched_scheduler_many_clients_tests,
};

kunit_test_suites(&drm_sched_scheduler_overhead,
		  &drm_sched_scheduler_two_clients1,
		  &drm_sched_scheduler_two_clients2,
		  &drm_sched_scheduler_many_clients);