root/tools/testing/selftests/powerpc/pmu/ebb/instruction_count_test.c

DEFINITIONS

1. do_count_loop
2. determine_overhead
3. pmc4_ebb_callee
4. instruction_count
5. main

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright 2014, Michael Ellerman, IBM Corp.
   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 
  21 extern void thirty_two_instruction_loop(uint64_t loops);
  22 
  23 static bool counters_frozen = true;
  24 
  25 static 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 */
  70 static 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 
  90 static 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);
 102 out:
 103         if (counters_frozen)
 104                 reset_ebb_with_clear_mask(MMCR0_PMAO);
 105         else
 106                 reset_ebb();
 107 }
 108 
 109 int 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 
 163 int main(void)
 164 {
 165         test_harness_set_timeout(300);
 166         return test_harness(instruction_count, "instruction_count");
 167 }