mirror of https://github.com/Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
164 lines
3.8 KiB
164 lines
3.8 KiB
/* |
|
* Copyright 2013, Michael Ellerman, IBM Corp. |
|
* Licensed under GPLv2. |
|
*/ |
|
|
|
#define _GNU_SOURCE |
|
|
|
#include <stdio.h> |
|
#include <stdbool.h> |
|
#include <string.h> |
|
#include <sys/prctl.h> |
|
|
|
#include "event.h" |
|
#include "utils.h" |
|
#include "lib.h" |
|
|
|
extern void thirty_two_instruction_loop_with_ll_sc(u64 loops, u64 *ll_sc_target); |
|
|
|
static void setup_event(struct event *e, u64 config, int type, char *name) |
|
{ |
|
event_init_opts(e, config, type, name); |
|
|
|
e->attr.disabled = 1; |
|
e->attr.exclude_kernel = 1; |
|
e->attr.exclude_hv = 1; |
|
e->attr.exclude_idle = 1; |
|
} |
|
|
|
static int do_count_loop(struct event *events, u64 instructions, |
|
u64 overhead, bool report) |
|
{ |
|
s64 difference, expected; |
|
double percentage; |
|
u64 dummy; |
|
|
|
prctl(PR_TASK_PERF_EVENTS_ENABLE); |
|
|
|
/* Run for 1M instructions */ |
|
thirty_two_instruction_loop_with_ll_sc(instructions >> 5, &dummy); |
|
|
|
prctl(PR_TASK_PERF_EVENTS_DISABLE); |
|
|
|
event_read(&events[0]); |
|
event_read(&events[1]); |
|
event_read(&events[2]); |
|
|
|
expected = instructions + overhead + (events[2].result.value * 10); |
|
difference = events[0].result.value - expected; |
|
percentage = (double)difference / events[0].result.value * 100; |
|
|
|
if (report) { |
|
printf("-----\n"); |
|
event_report(&events[0]); |
|
event_report(&events[1]); |
|
event_report(&events[2]); |
|
|
|
printf("Looped for %llu instructions, overhead %llu\n", instructions, overhead); |
|
printf("Expected %llu\n", expected); |
|
printf("Actual %llu\n", events[0].result.value); |
|
printf("Delta %lld, %f%%\n", difference, percentage); |
|
} |
|
|
|
event_reset(&events[0]); |
|
event_reset(&events[1]); |
|
event_reset(&events[2]); |
|
|
|
if (difference < 0) |
|
difference = -difference; |
|
|
|
/* Tolerate a difference below 0.0001 % */ |
|
difference *= 10000 * 100; |
|
if (difference / events[0].result.value) |
|
return -1; |
|
|
|
return 0; |
|
} |
|
|
|
/* Count how many instructions it takes to do a null loop */ |
|
static u64 determine_overhead(struct event *events) |
|
{ |
|
u64 current, overhead; |
|
int i; |
|
|
|
do_count_loop(events, 0, 0, false); |
|
overhead = events[0].result.value; |
|
|
|
for (i = 0; i < 100; i++) { |
|
do_count_loop(events, 0, 0, false); |
|
current = events[0].result.value; |
|
if (current < overhead) { |
|
printf("Replacing overhead %llu with %llu\n", overhead, current); |
|
overhead = current; |
|
} |
|
} |
|
|
|
return overhead; |
|
} |
|
|
|
#define PM_MRK_STCX_FAIL 0x03e158 |
|
#define PM_STCX_FAIL 0x01e058 |
|
|
|
static int test_body(void) |
|
{ |
|
struct event events[3]; |
|
u64 overhead; |
|
|
|
// The STCX_FAIL event we use works on Power8 or later |
|
SKIP_IF(!have_hwcap2(PPC_FEATURE2_ARCH_2_07)); |
|
|
|
setup_event(&events[0], PERF_COUNT_HW_INSTRUCTIONS, PERF_TYPE_HARDWARE, "instructions"); |
|
setup_event(&events[1], PERF_COUNT_HW_CPU_CYCLES, PERF_TYPE_HARDWARE, "cycles"); |
|
setup_event(&events[2], PM_STCX_FAIL, PERF_TYPE_RAW, "stcx_fail"); |
|
|
|
if (event_open(&events[0])) { |
|
perror("perf_event_open"); |
|
return -1; |
|
} |
|
|
|
if (event_open_with_group(&events[1], events[0].fd)) { |
|
perror("perf_event_open"); |
|
return -1; |
|
} |
|
|
|
if (event_open_with_group(&events[2], events[0].fd)) { |
|
perror("perf_event_open"); |
|
return -1; |
|
} |
|
|
|
overhead = determine_overhead(events); |
|
printf("Overhead of null loop: %llu instructions\n", overhead); |
|
|
|
/* Run for 1Mi instructions */ |
|
FAIL_IF(do_count_loop(events, 1000000, overhead, true)); |
|
|
|
/* Run for 10Mi instructions */ |
|
FAIL_IF(do_count_loop(events, 10000000, overhead, true)); |
|
|
|
/* Run for 100Mi instructions */ |
|
FAIL_IF(do_count_loop(events, 100000000, overhead, true)); |
|
|
|
/* Run for 1Bi instructions */ |
|
FAIL_IF(do_count_loop(events, 1000000000, overhead, true)); |
|
|
|
/* Run for 16Bi instructions */ |
|
FAIL_IF(do_count_loop(events, 16000000000, overhead, true)); |
|
|
|
/* Run for 64Bi instructions */ |
|
FAIL_IF(do_count_loop(events, 64000000000, overhead, true)); |
|
|
|
event_close(&events[0]); |
|
event_close(&events[1]); |
|
|
|
return 0; |
|
} |
|
|
|
static int count_ll_sc(void) |
|
{ |
|
return eat_cpu(test_body); |
|
} |
|
|
|
int main(void) |
|
{ |
|
return test_harness(count_ll_sc, "count_ll_sc"); |
|
}
|
|
|