testcases/kernel/sched/eas/sched_prio_3_rr.c

/*
 * Copyright (c) 2018 Google, Inc.
 *
 * SPDX-License-Identifier: GPL-2.0-or-later
 *
 * Three RT RR tasks are created and affined to the same CPU. They execute as
 * CPU hogs. Their runtime is checked to see that they share the CPU as
 * expected.
 */

#define _GNU_SOURCE
#include <errno.h>
#include <pthread.h>
#include <sched.h>
#include <semaphore.h>
#include <time.h>

#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_wakeup sched_switch sched_process_exit"

#define EXEC_MIN_PCT 32
#define EXEC_MAX_PCT 34

static sem_t sem;

static int rt_a_tid;
static int rt_b_tid;
static int rt_c_tid;

#define BUSY_WAIT_USECS 10000000
static void *rt_b_fn(void *arg LTP_ATTRIBUTE_UNUSED)
{
	rt_b_tid = gettid();
	affine(0);
	sem_wait(&sem);
	burn(BUSY_WAIT_USECS, 0);
	return NULL;
}

static void *rt_c_fn(void *arg LTP_ATTRIBUTE_UNUSED)
{
	rt_c_tid = gettid();
	affine(0);
	sem_wait(&sem);
	burn(BUSY_WAIT_USECS, 0);
	return NULL;
}

static void *rt_a_fn(void *arg LTP_ATTRIBUTE_UNUSED)
{
	rt_a_tid = gettid();
	affine(0);
	/* Give all other tasks a chance to affine and block. */
	usleep(3000);
	tracefs_write("trace_marker", "TEST START");
	sem_post(&sem);
	sem_post(&sem);
	burn(BUSY_WAIT_USECS, 0);
	return NULL;
}

static int parse_results(void)
{
	int i, pct, rv;
	int test_start = 0;
	unsigned long long exec_start_us = 0;
	unsigned long a_exec_us = 0;
	unsigned long b_exec_us = 0;
	unsigned long c_exec_us = 0;
	unsigned long total;

	for (i = 0; i < num_trace_records; i++) {
		struct trace_sched_switch *t = trace[i].event_data;
		unsigned long long segment_us;

		if (trace[i].event_type == TRACE_RECORD_TRACING_MARK_WRITE &&
		    !strcmp(trace[i].event_data, "TEST START")) {
			/* We need to include this segment in A's exec time. */
			exec_start_us = TS_TO_USEC(trace[i].ts);
			test_start = 1;
		}

		if (!test_start)
			continue;

		if (trace[i].event_type != TRACE_RECORD_SCHED_SWITCH)
			continue;

		segment_us = TS_TO_USEC(trace[i].ts) - exec_start_us;
		if (t->prev_pid == rt_a_tid)
			a_exec_us += segment_us;
		else if (t->prev_pid == rt_b_tid)
			b_exec_us += segment_us;
		else if (t->prev_pid == rt_c_tid)
			c_exec_us += segment_us;
		if (t->next_pid == rt_a_tid ||
		    t->next_pid == rt_b_tid ||
		    t->next_pid == rt_c_tid)
			exec_start_us = TS_TO_USEC(trace[i].ts);
	}

	rv = 0;
	total = a_exec_us + b_exec_us + c_exec_us;
	pct = (a_exec_us * 100) / total;
	rv |= (pct < EXEC_MIN_PCT || pct > EXEC_MAX_PCT);
	printf("a exec time: %ld usec (%d%%)\n", a_exec_us, pct);
	pct = (b_exec_us * 100) / total;
	rv |= (pct < EXEC_MIN_PCT || pct > EXEC_MAX_PCT);
	printf("b exec time: %ld usec (%d%%)\n", b_exec_us, pct);
	pct = (c_exec_us * 100) / total;
	rv |= (pct < EXEC_MIN_PCT || pct > EXEC_MAX_PCT);
	printf("c exec time: %ld usec (%d%%)\n", c_exec_us, pct);

	return rv;
}

static void create_rt_thread(int prio, void *fn, pthread_t *rt_thread)
{
	pthread_attr_t rt_thread_attrs;
	struct sched_param rt_thread_sched_params;

	ERROR_CHECK(pthread_attr_init(&rt_thread_attrs));
	ERROR_CHECK(pthread_attr_setinheritsched(&rt_thread_attrs,
						 PTHREAD_EXPLICIT_SCHED));
	ERROR_CHECK(pthread_attr_setschedpolicy(&rt_thread_attrs,
						SCHED_RR));
	rt_thread_sched_params.sched_priority = prio;
	ERROR_CHECK(pthread_attr_setschedparam(&rt_thread_attrs,
					       &rt_thread_sched_params));

	SAFE_PTHREAD_CREATE(rt_thread, &rt_thread_attrs, fn, NULL);
}

#define NUM_TASKS 3
static void run(void)
{
	pthread_t rt_a, rt_b, rt_c;

	sem_init(&sem, 0, 0);

	printf("Running %d RT RR tasks for 10 seconds...\n", NUM_TASKS);

	/* configure and enable tracing */
	tracefs_write("tracing_on", "0");
	tracefs_write("buffer_size_kb", "16384");
	tracefs_write("set_event", TRACE_EVENTS);
	tracefs_write("trace", "\n");
	tracefs_write("tracing_on", "1");

	create_rt_thread(70, rt_a_fn, &rt_a);
	create_rt_thread(70, rt_b_fn, &rt_b);
	create_rt_thread(70, rt_c_fn, &rt_c);

	SAFE_PTHREAD_JOIN(rt_a, NULL);
	SAFE_PTHREAD_JOIN(rt_b, NULL);
	SAFE_PTHREAD_JOIN(rt_c, NULL);

	/* disable tracing */
	tracefs_write("tracing_on", "0");
	LOAD_TRACE();

	if (parse_results())
		tst_res(TFAIL, "RT RR tasks did not receive the expected CPU "
			"time (all between %d-%d %% CPU).\n", EXEC_MIN_PCT,
			EXEC_MAX_PCT);
	else
		tst_res(TPASS, "RT RR tasks received the expected CPU time.\n");
}

static struct tst_test test = {
	.test_all = run,
	.setup = trace_setup,
	.cleanup = trace_cleanup,
};