| // 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 submission 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); |