Contributors: 4
Author Tokens Token Proportion Commits Commit Proportion
Benjamin Gray 600 77.62% 3 42.86%
Anshuman Khandual 147 19.02% 2 28.57%
Michael Ellerman 25 3.23% 1 14.29%
Thomas Gleixner 1 0.13% 1 14.29%
Total 773 7 


// SPDX-License-Identifier: GPL-2.0-only
/*
 * POWER Data Stream Control Register (DSCR) explicit test
 *
 * This test modifies the DSCR value using mtspr instruction and
 * verifies the change with mfspr instruction. It uses both the
 * privilege state SPR and the problem state SPR for this purpose.
 *
 * When using the privilege state SPR, the instructions such as
 * mfspr or mtspr are privileged and the kernel emulates them
 * for us. Instructions using problem state SPR can be executed
 * directly without any emulation if the HW supports them. Else
 * they also get emulated by the kernel.
 *
 * Copyright 2012, Anton Blanchard, IBM Corporation.
 * Copyright 2015, Anshuman Khandual, IBM Corporation.
 */

#define _GNU_SOURCE

#include "dscr.h"
#include "utils.h"

#include <pthread.h>
#include <sched.h>
#include <semaphore.h>

void *dscr_explicit_lockstep_thread(void *args)
{
	sem_t *prev = (sem_t *)args;
	sem_t *next = (sem_t *)args + 1;
	unsigned long expected_dscr = 0;

	set_dscr(expected_dscr);
	srand(gettid());

	for (int i = 0; i < COUNT; i++) {
		FAIL_IF_EXIT(sem_wait(prev));

		FAIL_IF_EXIT(expected_dscr != get_dscr());
		FAIL_IF_EXIT(expected_dscr != get_dscr_usr());

		expected_dscr = (expected_dscr + 1) % DSCR_MAX;
		set_dscr(expected_dscr);

		FAIL_IF_EXIT(sem_post(next));
	}

	return NULL;
}

int dscr_explicit_lockstep_test(void)
{
	pthread_t thread;
	sem_t semaphores[2];
	sem_t *prev = &semaphores[1];  /* reversed prev/next than for the other thread */
	sem_t *next = &semaphores[0];
	unsigned long expected_dscr = 0;

	SKIP_IF(!have_hwcap2(PPC_FEATURE2_DSCR));

	srand(gettid());
	set_dscr(expected_dscr);

	FAIL_IF(sem_init(prev, 0, 0));
	FAIL_IF(sem_init(next, 0, 1));  /* other thread starts first */
	FAIL_IF(bind_to_cpu(BIND_CPU_ANY) < 0);
	FAIL_IF(pthread_create(&thread, NULL, dscr_explicit_lockstep_thread, (void *)semaphores));

	for (int i = 0; i < COUNT; i++) {
		FAIL_IF(sem_wait(prev));

		FAIL_IF(expected_dscr != get_dscr());
		FAIL_IF(expected_dscr != get_dscr_usr());

		expected_dscr = (expected_dscr - 1) % DSCR_MAX;
		set_dscr(expected_dscr);

		FAIL_IF(sem_post(next));
	}

	FAIL_IF(pthread_join(thread, NULL));
	FAIL_IF(sem_destroy(prev));
	FAIL_IF(sem_destroy(next));

	return 0;
}

struct random_thread_args {
	pthread_t thread_id;
	bool do_yields;
	pthread_barrier_t *barrier;
};

void *dscr_explicit_random_thread(void *in)
{
	struct random_thread_args *args = (struct random_thread_args *)in;
	unsigned long expected_dscr = 0;
	int err;

	srand(gettid());

	err = pthread_barrier_wait(args->barrier);
	FAIL_IF_EXIT(err != 0 && err != PTHREAD_BARRIER_SERIAL_THREAD);

	for (int i = 0; i < COUNT; i++) {
		expected_dscr = rand() % DSCR_MAX;
		set_dscr(expected_dscr);

		for (int j = rand() % 5; j > 0; --j) {
			FAIL_IF_EXIT(get_dscr() != expected_dscr);
			FAIL_IF_EXIT(get_dscr_usr() != expected_dscr);

			if (args->do_yields && rand() % 2)
				sched_yield();
		}

		expected_dscr = rand() % DSCR_MAX;
		set_dscr_usr(expected_dscr);

		for (int j = rand() % 5; j > 0; --j) {
			FAIL_IF_EXIT(get_dscr() != expected_dscr);
			FAIL_IF_EXIT(get_dscr_usr() != expected_dscr);

			if (args->do_yields && rand() % 2)
				sched_yield();
		}
	}

	return NULL;
}

int dscr_explicit_random_test(void)
{
	struct random_thread_args threads[THREADS];
	pthread_barrier_t barrier;

	SKIP_IF(!have_hwcap2(PPC_FEATURE2_DSCR));

	FAIL_IF(pthread_barrier_init(&barrier, NULL, THREADS));

	for (int i = 0; i < THREADS; i++) {
		threads[i].do_yields = i % 2 == 0;
		threads[i].barrier = &barrier;

		FAIL_IF(pthread_create(&threads[i].thread_id, NULL,
				       dscr_explicit_random_thread, (void *)&threads[i]));
	}

	for (int i = 0; i < THREADS; i++)
		FAIL_IF(pthread_join(threads[i].thread_id, NULL));

	FAIL_IF(pthread_barrier_destroy(&barrier));

	return 0;
}

int main(int argc, char *argv[])
{
	unsigned long orig_dscr_default = 0;
	int err = 0;

	if (have_hwcap2(PPC_FEATURE2_DSCR))
		orig_dscr_default = get_default_dscr();

	err |= test_harness(dscr_explicit_lockstep_test, "dscr_explicit_lockstep_test");
	err |= test_harness(dscr_explicit_random_test, "dscr_explicit_random_test");

	if (have_hwcap2(PPC_FEATURE2_DSCR))
		set_default_dscr(orig_dscr_default);

	return err;
}