LXR linux/tools/testing/selftests/powerpc/pmu/ebb/instruction_count

   1/*
   2 * Copyright 2014, Michael Ellerman, IBM Corp.
   3 * Licensed under GPLv2.
   4 */
   5
   6#define _GNU_SOURCE
   7
   8#include <stdio.h>
   9#include <stdbool.h>
  10#include <string.h>
  11#include <sys/prctl.h>
  12
  13#include "ebb.h"
  14
  15
  16/*
  17 * Run a calibrated instruction loop and count instructions executed using
  18 * EBBs. Make sure the counts look right.
  19 */
  20
  21extern void thirty_two_instruction_loop(uint64_t loops);
  22
  23static bool counters_frozen = true;
  24
  25static int do_count_loop(struct event *event, uint64_t instructions,
  26                         uint64_t overhead, bool report)
  27{
  28        int64_t difference, expected;
  29        double percentage;
  30
  31        clear_ebb_stats();
  32
  33        counters_frozen = false;
  34        mb();
  35        mtspr(SPRN_MMCR0, mfspr(SPRN_MMCR0) & ~MMCR0_FC);
  36
  37        thirty_two_instruction_loop(instructions >> 5);
  38
  39        counters_frozen = true;
  40        mb();
  41        mtspr(SPRN_MMCR0, mfspr(SPRN_MMCR0) | MMCR0_FC);
  42
  43        count_pmc(4, sample_period);
  44
  45        event->result.value = ebb_state.stats.pmc_count[4-1];
  46        expected = instructions + overhead;
  47        difference = event->result.value - expected;
  48        percentage = (double)difference / event->result.value * 100;
  49
  50        if (report) {
  51                printf("Looped for %lu instructions, overhead %lu\n", instructions, overhead);
  52                printf("Expected %lu\n", expected);
  53                printf("Actual   %llu\n", event->result.value);
  54                printf("Delta    %ld, %f%%\n", difference, percentage);
  55                printf("Took %d EBBs\n", ebb_state.stats.ebb_count);
  56        }
  57
  58        if (difference < 0)
  59                difference = -difference;
  60
  61        /* Tolerate a difference of up to 0.0001 % */
  62        difference *= 10000 * 100;
  63        if (difference / event->result.value)
  64                return -1;
  65
  66        return 0;
  67}
  68
  69/* Count how many instructions it takes to do a null loop */
  70static uint64_t determine_overhead(struct event *event)
  71{
  72        uint64_t current, overhead;
  73        int i;
  74
  75        do_count_loop(event, 0, 0, false);
  76        overhead = event->result.value;
  77
  78        for (i = 0; i < 100; i++) {
  79                do_count_loop(event, 0, 0, false);
  80                current = event->result.value;
  81                if (current < overhead) {
  82                        printf("Replacing overhead %lu with %lu\n", overhead, current);
  83                        overhead = current;
  84                }
  85        }
  86
  87        return overhead;
  88}
  89
  90static void pmc4_ebb_callee(void)
  91{
  92        uint64_t val;
  93
  94        val = mfspr(SPRN_BESCR);
  95        if (!(val & BESCR_PMEO)) {
  96                ebb_state.stats.spurious++;
  97                goto out;
  98        }
  99
 100        ebb_state.stats.ebb_count++;
 101        count_pmc(4, sample_period);
 102out:
 103        if (counters_frozen)
 104                reset_ebb_with_clear_mask(MMCR0_PMAO);
 105        else
 106                reset_ebb();
 107}
 108
 109int instruction_count(void)
 110{
 111        struct event event;
 112        uint64_t overhead;
 113
 114        SKIP_IF(!ebb_is_supported());
 115
 116        event_init_named(&event, 0x400FA, "PM_RUN_INST_CMPL");
 117        event_leader_ebb_init(&event);
 118        event.attr.exclude_kernel = 1;
 119        event.attr.exclude_hv = 1;
 120        event.attr.exclude_idle = 1;
 121
 122        FAIL_IF(event_open(&event));
 123        FAIL_IF(ebb_event_enable(&event));
 124
 125        sample_period = COUNTER_OVERFLOW;
 126
 127        setup_ebb_handler(pmc4_ebb_callee);
 128        mtspr(SPRN_MMCR0, mfspr(SPRN_MMCR0) & ~MMCR0_FC);
 129        ebb_global_enable();
 130
 131        overhead = determine_overhead(&event);
 132        printf("Overhead of null loop: %lu instructions\n", overhead);
 133
 134        /* Run for 1M instructions */
 135        FAIL_IF(do_count_loop(&event, 0x100000, overhead, true));
 136
 137        /* Run for 10M instructions */
 138        FAIL_IF(do_count_loop(&event, 0xa00000, overhead, true));
 139
 140        /* Run for 100M instructions */
 141        FAIL_IF(do_count_loop(&event, 0x6400000, overhead, true));
 142
 143        /* Run for 1G instructions */
 144        FAIL_IF(do_count_loop(&event, 0x40000000, overhead, true));
 145
 146        /* Run for 16G instructions */
 147        FAIL_IF(do_count_loop(&event, 0x400000000, overhead, true));
 148
 149        /* Run for 64G instructions */
 150        FAIL_IF(do_count_loop(&event, 0x1000000000, overhead, true));
 151
 152        /* Run for 128G instructions */
 153        FAIL_IF(do_count_loop(&event, 0x2000000000, overhead, true));
 154
 155        ebb_global_disable();
 156        event_close(&event);
 157
 158        printf("Finished OK\n");
 159
 160        return 0;
 161}
 162
 163int main(void)
 164{
 165        return test_harness(instruction_count, "instruction_count");
 166}
 167