/* * Copyright (c) 2018 Google, Inc. * * SPDX-License-Identifier: GPL-2.0-or-later * * A task alternates between being big and small. Max up and down migration * latencies and task placement are verified. */ #define _GNU_SOURCE #include #include #include #include #include "tst_test.h" #include "tst_safe_file_ops.h" #include "tst_safe_pthread.h" #include "trace_parse.h" #include "util.h" #define TRACE_EVENTS "sched_switch" static int task_tid; #define MAX_UPMIGRATE_LATENCY_US 100000 #define MAX_DOWNMIGRATE_LATENCY_US 100000 #define MAX_INCORRECT_CLUSTER_PCT 10 #define BURN_SEC 1 #define NUM_LOOPS 10 static void *task_fn(void *arg LTP_ATTRIBUTE_UNUSED) { int loops = NUM_LOOPS; task_tid = gettid(); while (loops--) { SAFE_FILE_PRINTF(TRACING_DIR "trace_marker", "SMALL TASK"); burn(BURN_SEC * USEC_PER_SEC, 1); SAFE_FILE_PRINTF(TRACING_DIR "trace_marker", "CPU HOG"); burn(BURN_SEC * USEC_PER_SEC, 0); } return NULL; } static int parse_results(void) { int i, pct, rv = 0; unsigned long long exec_start_us = 0; unsigned long long too_big_cpu_us = 0; unsigned long long too_small_cpu_us = 0; unsigned long long small_task_us = 0; unsigned long long big_task_us = 0; unsigned long long smalltask_ts_usec = 0; unsigned long long cpuhog_ts_usec = 0; unsigned long long upmigrate_ts_usec = 0; unsigned long long downmigrate_ts_usec = 0; unsigned long long max_upmigrate_latency_usec = 0; unsigned long long max_downmigrate_latency_usec = 0; cpu_set_t cpuset; if (find_cpus_with_capacity(0, &cpuset)) { printf("Failed to find the CPUs in the little cluster.\n"); return -1; } for (i = 0; i < num_trace_records; i++) { unsigned long long segment_us; struct trace_sched_switch *t = trace[i].event_data; if (trace[i].event_type == TRACE_RECORD_TRACING_MARK_WRITE) { if (!strcmp(trace[i].event_data, "CPU HOG")) { /* Task is transitioning to cpu hog. */ cpuhog_ts_usec = TS_TO_USEC(trace[i].ts); if (downmigrate_ts_usec) { unsigned long long temp_latency; temp_latency = downmigrate_ts_usec - smalltask_ts_usec; if (temp_latency > max_downmigrate_latency_usec) max_downmigrate_latency_usec = temp_latency; } else if (smalltask_ts_usec) { printf("Warning: small task never " "downmigrated.\n"); rv = 1; } downmigrate_ts_usec = 0; smalltask_ts_usec = 0; } else if (!strcmp(trace[i].event_data, "SMALL TASK")) { smalltask_ts_usec = TS_TO_USEC(trace[i].ts); if (upmigrate_ts_usec) { unsigned long long temp_latency; temp_latency = upmigrate_ts_usec - cpuhog_ts_usec; if (temp_latency > max_upmigrate_latency_usec) max_upmigrate_latency_usec = temp_latency; } else if (cpuhog_ts_usec) { printf("Warning: big task never " "upmigrated.\n"); rv = 1; } upmigrate_ts_usec = 0; cpuhog_ts_usec = 0; } continue; } if (trace[i].event_type != TRACE_RECORD_SCHED_SWITCH) continue; if (t->next_pid == task_tid) { /* Start of task execution segment. */ if (exec_start_us) { printf("Trace parse fail: double exec start\n"); return -1; } exec_start_us = TS_TO_USEC(trace[i].ts); if (cpuhog_ts_usec && !upmigrate_ts_usec && !CPU_ISSET(trace[i].cpu, &cpuset)) upmigrate_ts_usec = exec_start_us; if (smalltask_ts_usec && !downmigrate_ts_usec && CPU_ISSET(trace[i].cpu, &cpuset)) downmigrate_ts_usec = exec_start_us; continue; } if (t->prev_pid != task_tid) continue; /* End of task execution segment. */ segment_us = TS_TO_USEC(trace[i].ts); segment_us -= exec_start_us; exec_start_us = 0; if (CPU_ISSET(trace[i].cpu, &cpuset)) { /* Task is running on little CPUs. */ if (cpuhog_ts_usec) { /* * Upmigration is accounted separately, so only * record mis-scheduled time here if it happened * after upmigration. */ if (upmigrate_ts_usec) too_small_cpu_us += segment_us; } } else { /* Task is running on big CPUs. */ if (smalltask_ts_usec) { /* * Downmigration is accounted separately, so * only record mis-scheduled time here if it * happened after downmigration. */ if (downmigrate_ts_usec) too_big_cpu_us += segment_us; } } if (cpuhog_ts_usec) big_task_us += segment_us; if (smalltask_ts_usec) small_task_us += segment_us; } pct = (too_big_cpu_us * 100) / small_task_us; rv |= (pct > MAX_INCORRECT_CLUSTER_PCT); printf("Time incorrectly scheduled on big when task was small, " "after downmigration: " "%lld usec (%d%% of small task CPU time)\n", too_big_cpu_us, pct); pct = (too_small_cpu_us * 100) / big_task_us; rv |= (pct > MAX_INCORRECT_CLUSTER_PCT); printf("Time incorrectly scheduled on small when task was big, " "after upmigration: " "%lld usec (%d%% of big task CPU time)\n", too_small_cpu_us, pct); printf("small task time: %lld\nbig task time: %lld\n", small_task_us, big_task_us); printf("Maximum upmigration time: %lld\n", max_upmigrate_latency_usec); printf("Maximum downmigration time: %lld\n", max_downmigrate_latency_usec); return (rv || max_upmigrate_latency_usec > MAX_UPMIGRATE_LATENCY_US || max_downmigrate_latency_usec > MAX_DOWNMIGRATE_LATENCY_US); } static void run(void) { pthread_t task_thread; tst_res(TINFO, "Maximum incorrect cluster time percentage: %d%%", MAX_INCORRECT_CLUSTER_PCT); tst_res(TINFO, "Maximum downmigration latency: %d usec", MAX_DOWNMIGRATE_LATENCY_US); tst_res(TINFO, "Maximum upmigration latency: %d usec", MAX_UPMIGRATE_LATENCY_US); printf("Task alternating between big and small for %d sec\n", BURN_SEC * NUM_LOOPS * 2); /* configure and enable tracing */ SAFE_FILE_PRINTF(TRACING_DIR "tracing_on", "0"); SAFE_FILE_PRINTF(TRACING_DIR "buffer_size_kb", "16384"); SAFE_FILE_PRINTF(TRACING_DIR "set_event", TRACE_EVENTS); SAFE_FILE_PRINTF(TRACING_DIR "trace", "\n"); SAFE_FILE_PRINTF(TRACING_DIR "tracing_on", "1"); SAFE_PTHREAD_CREATE(&task_thread, NULL, task_fn, NULL); SAFE_PTHREAD_JOIN(task_thread, NULL); /* disable tracing */ SAFE_FILE_PRINTF(TRACING_DIR "tracing_on", "0"); LOAD_TRACE(); if (parse_results()) tst_res(TFAIL, "Task placement and migration latency goals " "were not met.\n"); else tst_res(TPASS, "Task placement and migration latency goals " "were met.\n"); } static struct tst_test test = { .test_all = run, .cleanup = trace_cleanup, };