Quelle  dscr_explicit_test.c   Sprache: C

// 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;
}