| /**************************************************************************** |
| ** |
| ** Copyright (C) 2016 Intel Corporation. |
| ** Contact: https://www.qt.io/licensing/ |
| ** |
| ** This file is part of the QtCore module of the Qt Toolkit. |
| ** |
| ** $QT_BEGIN_LICENSE:LGPL$ |
| ** Commercial License Usage |
| ** Licensees holding valid commercial Qt licenses may use this file in |
| ** accordance with the commercial license agreement provided with the |
| ** Software or, alternatively, in accordance with the terms contained in |
| ** a written agreement between you and The Qt Company. For licensing terms |
| ** and conditions see https://www.qt.io/terms-conditions. For further |
| ** information use the contact form at https://www.qt.io/contact-us. |
| ** |
| ** GNU Lesser General Public License Usage |
| ** Alternatively, this file may be used under the terms of the GNU Lesser |
| ** General Public License version 3 as published by the Free Software |
| ** Foundation and appearing in the file LICENSE.LGPL3 included in the |
| ** packaging of this file. Please review the following information to |
| ** ensure the GNU Lesser General Public License version 3 requirements |
| ** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. |
| ** |
| ** GNU General Public License Usage |
| ** Alternatively, this file may be used under the terms of the GNU |
| ** General Public License version 2.0 or (at your option) the GNU General |
| ** Public license version 3 or any later version approved by the KDE Free |
| ** Qt Foundation. The licenses are as published by the Free Software |
| ** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 |
| ** included in the packaging of this file. Please review the following |
| ** information to ensure the GNU General Public License requirements will |
| ** be met: https://www.gnu.org/licenses/gpl-2.0.html and |
| ** https://www.gnu.org/licenses/gpl-3.0.html. |
| ** |
| ** $QT_END_LICENSE$ |
| ** |
| ****************************************************************************/ |
| |
| #include "qbenchmarkperfevents_p.h" |
| #include "qbenchmarkmetric.h" |
| #include "qbenchmark_p.h" |
| |
| #ifdef QTESTLIB_USE_PERF_EVENTS |
| |
| // include the qcore_unix_p.h without core-private |
| // we only use inline functions anyway |
| #include "../corelib/kernel/qcore_unix_p.h" |
| |
| #include <sys/types.h> |
| #include <errno.h> |
| #include <fcntl.h> |
| #include <string.h> |
| #include <stdio.h> |
| |
| #include <sys/syscall.h> |
| #include <sys/ioctl.h> |
| |
| #include "3rdparty/linux_perf_event_p.h" |
| |
| // for PERF_TYPE_HW_CACHE, the config is a bitmask |
| // lowest 8 bits: cache type |
| // bits 8 to 15: cache operation |
| // bits 16 to 23: cache result |
| #define CACHE_L1D_READ (PERF_COUNT_HW_CACHE_L1D | PERF_COUNT_HW_CACHE_OP_READ << 8 | PERF_COUNT_HW_CACHE_RESULT_ACCESS << 16) |
| #define CACHE_L1D_WRITE (PERF_COUNT_HW_CACHE_L1D | PERF_COUNT_HW_CACHE_OP_WRITE << 8 | PERF_COUNT_HW_CACHE_RESULT_ACCESS << 16) |
| #define CACHE_L1D_PREFETCH (PERF_COUNT_HW_CACHE_L1D | PERF_COUNT_HW_CACHE_OP_PREFETCH << 8 | PERF_COUNT_HW_CACHE_RESULT_ACCESS << 16) |
| #define CACHE_L1I_READ (PERF_COUNT_HW_CACHE_L1I | PERF_COUNT_HW_CACHE_OP_READ << 8 | PERF_COUNT_HW_CACHE_RESULT_ACCESS << 16) |
| #define CACHE_L1I_PREFETCH (PERF_COUNT_HW_CACHE_L1I | PERF_COUNT_HW_CACHE_OP_PREFETCH << 8 | PERF_COUNT_HW_CACHE_RESULT_ACCESS << 16) |
| #define CACHE_LLC_READ (PERF_COUNT_HW_CACHE_LL | PERF_COUNT_HW_CACHE_OP_READ << 8 | PERF_COUNT_HW_CACHE_RESULT_ACCESS << 16) |
| #define CACHE_LLC_WRITE (PERF_COUNT_HW_CACHE_LL | PERF_COUNT_HW_CACHE_OP_WRITE << 8| PERF_COUNT_HW_CACHE_RESULT_ACCESS << 16) |
| #define CACHE_LLC_PREFETCH (PERF_COUNT_HW_CACHE_LL | PERF_COUNT_HW_CACHE_OP_PREFETCH << 8 | PERF_COUNT_HW_CACHE_RESULT_ACCESS << 16) |
| #define CACHE_L1D_READ_MISS (PERF_COUNT_HW_CACHE_L1D | PERF_COUNT_HW_CACHE_OP_READ << 8 | PERF_COUNT_HW_CACHE_RESULT_MISS << 16) |
| #define CACHE_L1D_WRITE_MISS (PERF_COUNT_HW_CACHE_L1D | PERF_COUNT_HW_CACHE_OP_WRITE << 8 | PERF_COUNT_HW_CACHE_RESULT_MISS << 16) |
| #define CACHE_L1D_PREFETCH_MISS (PERF_COUNT_HW_CACHE_L1D | PERF_COUNT_HW_CACHE_OP_PREFETCH << 8 | PERF_COUNT_HW_CACHE_RESULT_MISS << 16) |
| #define CACHE_L1I_READ_MISS (PERF_COUNT_HW_CACHE_L1I | PERF_COUNT_HW_CACHE_OP_READ << 8 | PERF_COUNT_HW_CACHE_RESULT_MISS << 16) |
| #define CACHE_L1I_PREFETCH_MISS (PERF_COUNT_HW_CACHE_L1I | PERF_COUNT_HW_CACHE_OP_PREFETCH << 8 | PERF_COUNT_HW_CACHE_RESULT_MISS << 16) |
| #define CACHE_LLC_READ_MISS (PERF_COUNT_HW_CACHE_LL | PERF_COUNT_HW_CACHE_OP_READ << 8 | PERF_COUNT_HW_CACHE_RESULT_MISS << 16) |
| #define CACHE_LLC_WRITE_MISS (PERF_COUNT_HW_CACHE_LL | PERF_COUNT_HW_CACHE_OP_WRITE << 8 | PERF_COUNT_HW_CACHE_RESULT_MISS << 16) |
| #define CACHE_LLC_PREFETCH_MISS (PERF_COUNT_HW_CACHE_LL | PERF_COUNT_HW_CACHE_OP_PREFETCH << 8 | PERF_COUNT_HW_CACHE_RESULT_MISS << 16) |
| #define CACHE_BRANCH_READ (PERF_COUNT_HW_CACHE_BPU | PERF_COUNT_HW_CACHE_OP_READ << 8 | PERF_COUNT_HW_CACHE_RESULT_ACCESS << 16) |
| #define CACHE_BRANCH_READ_MISS (PERF_COUNT_HW_CACHE_BPU | PERF_COUNT_HW_CACHE_OP_READ << 8 | PERF_COUNT_HW_CACHE_RESULT_MISS << 16) |
| |
| QT_BEGIN_NAMESPACE |
| |
| static perf_event_attr attr; |
| |
| static void initPerf() |
| { |
| static bool done; |
| if (!done) { |
| memset(&attr, 0, sizeof attr); |
| attr.size = sizeof attr; |
| attr.read_format = PERF_FORMAT_TOTAL_TIME_ENABLED | PERF_FORMAT_TOTAL_TIME_RUNNING; |
| attr.disabled = true; // we'll enable later |
| attr.inherit = true; // let children processes inherit the monitoring |
| attr.pinned = true; // keep it running in the hardware |
| attr.inherit_stat = true; // aggregate all the info from child processes |
| attr.task = true; // trace fork/exits |
| |
| // set a default performance counter: CPU cycles |
| attr.type = PERF_TYPE_HARDWARE; |
| attr.config = PERF_COUNT_HW_CPU_CYCLES; // default |
| |
| done = true; |
| } |
| } |
| |
| // This class does not exist in the API so it's qdoc comment marker was removed. |
| |
| /* |
| \class QBenchmarkPerfEvents |
| \brief The Linux perf events benchmark backend |
| |
| This benchmark backend uses the Linux Performance Counters interface, |
| introduced with the Linux kernel v2.6.31. The interface is done by one |
| system call (perf_event_open) which takes an attribute structure and |
| returns a file descriptor. |
| |
| More information: |
| \li design docs: tools/perf/design.txt <http://lxr.linux.no/linux/tools/perf/design.txt> |
| \li sample tool: tools/perf/builtin-stat.c <http://lxr.linux.no/linux/tools/perf/builtin-stat.c> |
| (note: as of v3.3.1, the documentation is out-of-date with the kernel |
| interface, so reading the source code of existing tools is necessary) |
| |
| This benchlib backend monitors the current process as well as child process |
| launched. We do not try to benchmark in kernel or hypervisor mode, as that |
| usually requires elevated privileges. |
| */ |
| |
| static int perf_event_open(perf_event_attr *attr, pid_t pid, int cpu, int group_fd, unsigned long flags) |
| { |
| #ifdef SYS_perf_event_open |
| return syscall(SYS_perf_event_open, attr, pid, cpu, group_fd, flags); |
| #else |
| Q_UNUSED(attr); |
| Q_UNUSED(pid); |
| Q_UNUSED(cpu); |
| Q_UNUSED(group_fd); |
| Q_UNUSED(flags); |
| errno = ENOSYS; |
| return -1; |
| #endif |
| } |
| |
| bool QBenchmarkPerfEventsMeasurer::isAvailable() |
| { |
| // this generates an EFAULT because attr == NULL if perf_event_open is available |
| // if the kernel is too old, it generates ENOSYS |
| return perf_event_open(nullptr, 0, 0, 0, 0) == -1 && errno != ENOSYS; |
| } |
| |
| /* Event list structure |
| The following table provides the list of supported events |
| |
| Event type Event counter Unit Name and aliases |
| HARDWARE CPU_CYCLES CPUCycles cycles cpu-cycles |
| HARDWARE REF_CPU_CYCLES RefCPUCycles ref-cycles |
| HARDWARE INSTRUCTIONS Instructions instructions |
| HARDWARE CACHE_REFERENCES CacheReferences cache-references |
| HARDWARE CACHE_MISSES CacheMisses cache-misses |
| HARDWARE BRANCH_INSTRUCTIONS BranchInstructions branch-instructions branches |
| HARDWARE BRANCH_MISSES BranchMisses branch-misses |
| HARDWARE BUS_CYCLES BusCycles bus-cycles |
| HARDWARE STALLED_CYCLES_FRONTEND StalledCycles stalled-cycles-frontend idle-cycles-frontend |
| HARDWARE STALLED_CYCLES_BACKEND StalledCycles stalled-cycles-backend idle-cycles-backend |
| SOFTWARE CPU_CLOCK WalltimeMilliseconds cpu-clock |
| SOFTWARE TASK_CLOCK WalltimeMilliseconds task-clock |
| SOFTWARE PAGE_FAULTS PageFaults page-faults faults |
| SOFTWARE PAGE_FAULTS_MAJ MajorPageFaults major-faults |
| SOFTWARE PAGE_FAULTS_MIN MinorPageFaults minor-faults |
| SOFTWARE CONTEXT_SWITCHES ContextSwitches context-switches cs |
| SOFTWARE CPU_MIGRATIONS CPUMigrations cpu-migrations migrations |
| SOFTWARE ALIGNMENT_FAULTS AlignmentFaults alignment-faults |
| SOFTWARE EMULATION_FAULTS EmulationFaults emulation-faults |
| HW_CACHE L1D_READ CacheReads l1d-cache-reads l1d-cache-loads l1d-reads l1d-loads |
| HW_CACHE L1D_WRITE CacheWrites l1d-cache-writes l1d-cache-stores l1d-writes l1d-stores |
| HW_CACHE L1D_PREFETCH CachePrefetches l1d-cache-prefetches l1d-prefetches |
| HW_CACHE L1I_READ CacheReads l1i-cache-reads l1i-cache-loads l1i-reads l1i-loads |
| HW_CACHE L1I_PREFETCH CachePrefetches l1i-cache-prefetches l1i-prefetches |
| HW_CACHE LLC_READ CacheReads llc-cache-reads llc-cache-loads llc-loads llc-reads |
| HW_CACHE LLC_WRITE CacheWrites llc-cache-writes llc-cache-stores llc-writes llc-stores |
| HW_CACHE LLC_PREFETCH CachePrefetches llc-cache-prefetches llc-prefetches |
| HW_CACHE L1D_READ_MISS CacheReads l1d-cache-read-misses l1d-cache-load-misses l1d-read-misses l1d-load-misses |
| HW_CACHE L1D_WRITE_MISS CacheWrites l1d-cache-write-misses l1d-cache-store-misses l1d-write-misses l1d-store-misses |
| HW_CACHE L1D_PREFETCH_MISS CachePrefetches l1d-cache-prefetch-misses l1d-prefetch-misses |
| HW_CACHE L1I_READ_MISS CacheReads l1i-cache-read-misses l1i-cache-load-misses l1i-read-misses l1i-load-misses |
| HW_CACHE L1I_PREFETCH_MISS CachePrefetches l1i-cache-prefetch-misses l1i-prefetch-misses |
| HW_CACHE LLC_READ_MISS CacheReads llc-cache-read-misses llc-cache-load-misses llc-read-misses llc-load-misses |
| HW_CACHE LLC_WRITE_MISS CacheWrites llc-cache-write-misses llc-cache-store-misses llc-write-misses llc-store-misses |
| HW_CACHE LLC_PREFETCH_MISS CachePrefetches llc-cache-prefetch-misses llc-prefetch-misses |
| HW_CACHE BRANCH_READ BranchInstructions branch-reads branch-loads branch-predicts |
| HW_CACHE BRANCH_READ_MISS BranchMisses branch-mispredicts branch-read-misses branch-load-misses |
| |
| Use the following Perl script to re-generate the list |
| === cut perl === |
| #!/usr/bin/env perl |
| # Load all entries into %map |
| while (<STDIN>) { |
| m/^\s*(.*)\s*$/; |
| @_ = split /\s+/, $1; |
| $type = shift @_; |
| $id = ($type eq "HARDWARE" ? "PERF_COUNT_HW_" : |
| $type eq "SOFTWARE" ? "PERF_COUNT_SW_" : |
| $type eq "HW_CACHE" ? "CACHE_" : "") . shift @_; |
| $unit = shift @_; |
| |
| for $string (@_) { |
| die "$string was already seen!" if defined($map{$string}); |
| $map{$string} = [-1, $type, $id, $unit]; |
| push @strings, $string; |
| } |
| } |
| |
| # sort the map and print the string list |
| @strings = sort @strings; |
| print "static const char eventlist_strings[] = \n"; |
| $counter = 0; |
| for $entry (@strings) { |
| print " \"$entry\\0\"\n"; |
| $map{$entry}[0] = $counter; |
| $counter += 1 + length $entry; |
| } |
| |
| # print the table |
| print " \"\\0\";\n\nstatic const Events eventlist[] = {\n"; |
| for $entry (sort @strings) { |
| printf " { %3d, PERF_TYPE_%s, %s, QTest::%s },\n", |
| $map{$entry}[0], |
| $map{$entry}[1], |
| $map{$entry}[2], |
| $map{$entry}[3]; |
| } |
| print " { 0, PERF_TYPE_MAX, 0, QTest::Events }\n};\n"; |
| === cut perl === |
| */ |
| |
| struct Events { |
| unsigned offset; |
| quint32 type; |
| quint64 event_id; |
| QTest::QBenchmarkMetric metric; |
| }; |
| |
| /* -- BEGIN GENERATED CODE -- */ |
| static const char eventlist_strings[] = |
| "alignment-faults\0" |
| "branch-instructions\0" |
| "branch-load-misses\0" |
| "branch-loads\0" |
| "branch-mispredicts\0" |
| "branch-misses\0" |
| "branch-predicts\0" |
| "branch-read-misses\0" |
| "branch-reads\0" |
| "branches\0" |
| "bus-cycles\0" |
| "cache-misses\0" |
| "cache-references\0" |
| "context-switches\0" |
| "cpu-clock\0" |
| "cpu-cycles\0" |
| "cpu-migrations\0" |
| "cs\0" |
| "cycles\0" |
| "emulation-faults\0" |
| "faults\0" |
| "idle-cycles-backend\0" |
| "idle-cycles-frontend\0" |
| "instructions\0" |
| "l1d-cache-load-misses\0" |
| "l1d-cache-loads\0" |
| "l1d-cache-prefetch-misses\0" |
| "l1d-cache-prefetches\0" |
| "l1d-cache-read-misses\0" |
| "l1d-cache-reads\0" |
| "l1d-cache-store-misses\0" |
| "l1d-cache-stores\0" |
| "l1d-cache-write-misses\0" |
| "l1d-cache-writes\0" |
| "l1d-load-misses\0" |
| "l1d-loads\0" |
| "l1d-prefetch-misses\0" |
| "l1d-prefetches\0" |
| "l1d-read-misses\0" |
| "l1d-reads\0" |
| "l1d-store-misses\0" |
| "l1d-stores\0" |
| "l1d-write-misses\0" |
| "l1d-writes\0" |
| "l1i-cache-load-misses\0" |
| "l1i-cache-loads\0" |
| "l1i-cache-prefetch-misses\0" |
| "l1i-cache-prefetches\0" |
| "l1i-cache-read-misses\0" |
| "l1i-cache-reads\0" |
| "l1i-load-misses\0" |
| "l1i-loads\0" |
| "l1i-prefetch-misses\0" |
| "l1i-prefetches\0" |
| "l1i-read-misses\0" |
| "l1i-reads\0" |
| "llc-cache-load-misses\0" |
| "llc-cache-loads\0" |
| "llc-cache-prefetch-misses\0" |
| "llc-cache-prefetches\0" |
| "llc-cache-read-misses\0" |
| "llc-cache-reads\0" |
| "llc-cache-store-misses\0" |
| "llc-cache-stores\0" |
| "llc-cache-write-misses\0" |
| "llc-cache-writes\0" |
| "llc-load-misses\0" |
| "llc-loads\0" |
| "llc-prefetch-misses\0" |
| "llc-prefetches\0" |
| "llc-read-misses\0" |
| "llc-reads\0" |
| "llc-store-misses\0" |
| "llc-stores\0" |
| "llc-write-misses\0" |
| "llc-writes\0" |
| "major-faults\0" |
| "migrations\0" |
| "minor-faults\0" |
| "page-faults\0" |
| "ref-cycles\0" |
| "stalled-cycles-backend\0" |
| "stalled-cycles-frontend\0" |
| "task-clock\0" |
| "\0"; |
| |
| static const Events eventlist[] = { |
| { 0, PERF_TYPE_SOFTWARE, PERF_COUNT_SW_ALIGNMENT_FAULTS, QTest::AlignmentFaults }, |
| { 17, PERF_TYPE_HARDWARE, PERF_COUNT_HW_BRANCH_INSTRUCTIONS, QTest::BranchInstructions }, |
| { 37, PERF_TYPE_HW_CACHE, CACHE_BRANCH_READ_MISS, QTest::BranchMisses }, |
| { 56, PERF_TYPE_HW_CACHE, CACHE_BRANCH_READ, QTest::BranchInstructions }, |
| { 69, PERF_TYPE_HW_CACHE, CACHE_BRANCH_READ_MISS, QTest::BranchMisses }, |
| { 88, PERF_TYPE_HARDWARE, PERF_COUNT_HW_BRANCH_MISSES, QTest::BranchMisses }, |
| { 102, PERF_TYPE_HW_CACHE, CACHE_BRANCH_READ, QTest::BranchInstructions }, |
| { 118, PERF_TYPE_HW_CACHE, CACHE_BRANCH_READ_MISS, QTest::BranchMisses }, |
| { 137, PERF_TYPE_HW_CACHE, CACHE_BRANCH_READ, QTest::BranchInstructions }, |
| { 150, PERF_TYPE_HARDWARE, PERF_COUNT_HW_BRANCH_INSTRUCTIONS, QTest::BranchInstructions }, |
| { 159, PERF_TYPE_HARDWARE, PERF_COUNT_HW_BUS_CYCLES, QTest::BusCycles }, |
| { 170, PERF_TYPE_HARDWARE, PERF_COUNT_HW_CACHE_MISSES, QTest::CacheMisses }, |
| { 183, PERF_TYPE_HARDWARE, PERF_COUNT_HW_CACHE_REFERENCES, QTest::CacheReferences }, |
| { 200, PERF_TYPE_SOFTWARE, PERF_COUNT_SW_CONTEXT_SWITCHES, QTest::ContextSwitches }, |
| { 217, PERF_TYPE_SOFTWARE, PERF_COUNT_SW_CPU_CLOCK, QTest::WalltimeMilliseconds }, |
| { 227, PERF_TYPE_HARDWARE, PERF_COUNT_HW_CPU_CYCLES, QTest::CPUCycles }, |
| { 238, PERF_TYPE_SOFTWARE, PERF_COUNT_SW_CPU_MIGRATIONS, QTest::CPUMigrations }, |
| { 253, PERF_TYPE_SOFTWARE, PERF_COUNT_SW_CONTEXT_SWITCHES, QTest::ContextSwitches }, |
| { 256, PERF_TYPE_HARDWARE, PERF_COUNT_HW_CPU_CYCLES, QTest::CPUCycles }, |
| { 263, PERF_TYPE_SOFTWARE, PERF_COUNT_SW_EMULATION_FAULTS, QTest::EmulationFaults }, |
| { 280, PERF_TYPE_SOFTWARE, PERF_COUNT_SW_PAGE_FAULTS, QTest::PageFaults }, |
| { 287, PERF_TYPE_HARDWARE, PERF_COUNT_HW_STALLED_CYCLES_BACKEND, QTest::StalledCycles }, |
| { 307, PERF_TYPE_HARDWARE, PERF_COUNT_HW_STALLED_CYCLES_FRONTEND, QTest::StalledCycles }, |
| { 328, PERF_TYPE_HARDWARE, PERF_COUNT_HW_INSTRUCTIONS, QTest::Instructions }, |
| { 341, PERF_TYPE_HW_CACHE, CACHE_L1D_READ_MISS, QTest::CacheReads }, |
| { 363, PERF_TYPE_HW_CACHE, CACHE_L1D_READ, QTest::CacheReads }, |
| { 379, PERF_TYPE_HW_CACHE, CACHE_L1D_PREFETCH_MISS, QTest::CachePrefetches }, |
| { 405, PERF_TYPE_HW_CACHE, CACHE_L1D_PREFETCH, QTest::CachePrefetches }, |
| { 426, PERF_TYPE_HW_CACHE, CACHE_L1D_READ_MISS, QTest::CacheReads }, |
| { 448, PERF_TYPE_HW_CACHE, CACHE_L1D_READ, QTest::CacheReads }, |
| { 464, PERF_TYPE_HW_CACHE, CACHE_L1D_WRITE_MISS, QTest::CacheWrites }, |
| { 487, PERF_TYPE_HW_CACHE, CACHE_L1D_WRITE, QTest::CacheWrites }, |
| { 504, PERF_TYPE_HW_CACHE, CACHE_L1D_WRITE_MISS, QTest::CacheWrites }, |
| { 527, PERF_TYPE_HW_CACHE, CACHE_L1D_WRITE, QTest::CacheWrites }, |
| { 544, PERF_TYPE_HW_CACHE, CACHE_L1D_READ_MISS, QTest::CacheReads }, |
| { 560, PERF_TYPE_HW_CACHE, CACHE_L1D_READ, QTest::CacheReads }, |
| { 570, PERF_TYPE_HW_CACHE, CACHE_L1D_PREFETCH_MISS, QTest::CachePrefetches }, |
| { 590, PERF_TYPE_HW_CACHE, CACHE_L1D_PREFETCH, QTest::CachePrefetches }, |
| { 605, PERF_TYPE_HW_CACHE, CACHE_L1D_READ_MISS, QTest::CacheReads }, |
| { 621, PERF_TYPE_HW_CACHE, CACHE_L1D_READ, QTest::CacheReads }, |
| { 631, PERF_TYPE_HW_CACHE, CACHE_L1D_WRITE_MISS, QTest::CacheWrites }, |
| { 648, PERF_TYPE_HW_CACHE, CACHE_L1D_WRITE, QTest::CacheWrites }, |
| { 659, PERF_TYPE_HW_CACHE, CACHE_L1D_WRITE_MISS, QTest::CacheWrites }, |
| { 676, PERF_TYPE_HW_CACHE, CACHE_L1D_WRITE, QTest::CacheWrites }, |
| { 687, PERF_TYPE_HW_CACHE, CACHE_L1I_READ_MISS, QTest::CacheReads }, |
| { 709, PERF_TYPE_HW_CACHE, CACHE_L1I_READ, QTest::CacheReads }, |
| { 725, PERF_TYPE_HW_CACHE, CACHE_L1I_PREFETCH_MISS, QTest::CachePrefetches }, |
| { 751, PERF_TYPE_HW_CACHE, CACHE_L1I_PREFETCH, QTest::CachePrefetches }, |
| { 772, PERF_TYPE_HW_CACHE, CACHE_L1I_READ_MISS, QTest::CacheReads }, |
| { 794, PERF_TYPE_HW_CACHE, CACHE_L1I_READ, QTest::CacheReads }, |
| { 810, PERF_TYPE_HW_CACHE, CACHE_L1I_READ_MISS, QTest::CacheReads }, |
| { 826, PERF_TYPE_HW_CACHE, CACHE_L1I_READ, QTest::CacheReads }, |
| { 836, PERF_TYPE_HW_CACHE, CACHE_L1I_PREFETCH_MISS, QTest::CachePrefetches }, |
| { 856, PERF_TYPE_HW_CACHE, CACHE_L1I_PREFETCH, QTest::CachePrefetches }, |
| { 871, PERF_TYPE_HW_CACHE, CACHE_L1I_READ_MISS, QTest::CacheReads }, |
| { 887, PERF_TYPE_HW_CACHE, CACHE_L1I_READ, QTest::CacheReads }, |
| { 897, PERF_TYPE_HW_CACHE, CACHE_LLC_READ_MISS, QTest::CacheReads }, |
| { 919, PERF_TYPE_HW_CACHE, CACHE_LLC_READ, QTest::CacheReads }, |
| { 935, PERF_TYPE_HW_CACHE, CACHE_LLC_PREFETCH_MISS, QTest::CachePrefetches }, |
| { 961, PERF_TYPE_HW_CACHE, CACHE_LLC_PREFETCH, QTest::CachePrefetches }, |
| { 982, PERF_TYPE_HW_CACHE, CACHE_LLC_READ_MISS, QTest::CacheReads }, |
| { 1004, PERF_TYPE_HW_CACHE, CACHE_LLC_READ, QTest::CacheReads }, |
| { 1020, PERF_TYPE_HW_CACHE, CACHE_LLC_WRITE_MISS, QTest::CacheWrites }, |
| { 1043, PERF_TYPE_HW_CACHE, CACHE_LLC_WRITE, QTest::CacheWrites }, |
| { 1060, PERF_TYPE_HW_CACHE, CACHE_LLC_WRITE_MISS, QTest::CacheWrites }, |
| { 1083, PERF_TYPE_HW_CACHE, CACHE_LLC_WRITE, QTest::CacheWrites }, |
| { 1100, PERF_TYPE_HW_CACHE, CACHE_LLC_READ_MISS, QTest::CacheReads }, |
| { 1116, PERF_TYPE_HW_CACHE, CACHE_LLC_READ, QTest::CacheReads }, |
| { 1126, PERF_TYPE_HW_CACHE, CACHE_LLC_PREFETCH_MISS, QTest::CachePrefetches }, |
| { 1146, PERF_TYPE_HW_CACHE, CACHE_LLC_PREFETCH, QTest::CachePrefetches }, |
| { 1161, PERF_TYPE_HW_CACHE, CACHE_LLC_READ_MISS, QTest::CacheReads }, |
| { 1177, PERF_TYPE_HW_CACHE, CACHE_LLC_READ, QTest::CacheReads }, |
| { 1187, PERF_TYPE_HW_CACHE, CACHE_LLC_WRITE_MISS, QTest::CacheWrites }, |
| { 1204, PERF_TYPE_HW_CACHE, CACHE_LLC_WRITE, QTest::CacheWrites }, |
| { 1215, PERF_TYPE_HW_CACHE, CACHE_LLC_WRITE_MISS, QTest::CacheWrites }, |
| { 1232, PERF_TYPE_HW_CACHE, CACHE_LLC_WRITE, QTest::CacheWrites }, |
| { 1243, PERF_TYPE_SOFTWARE, PERF_COUNT_SW_PAGE_FAULTS_MAJ, QTest::MajorPageFaults }, |
| { 1256, PERF_TYPE_SOFTWARE, PERF_COUNT_SW_CPU_MIGRATIONS, QTest::CPUMigrations }, |
| { 1267, PERF_TYPE_SOFTWARE, PERF_COUNT_SW_PAGE_FAULTS_MIN, QTest::MinorPageFaults }, |
| { 1280, PERF_TYPE_SOFTWARE, PERF_COUNT_SW_PAGE_FAULTS, QTest::PageFaults }, |
| { 1292, PERF_TYPE_HARDWARE, PERF_COUNT_HW_REF_CPU_CYCLES, QTest::RefCPUCycles }, |
| { 1303, PERF_TYPE_HARDWARE, PERF_COUNT_HW_STALLED_CYCLES_BACKEND, QTest::StalledCycles }, |
| { 1326, PERF_TYPE_HARDWARE, PERF_COUNT_HW_STALLED_CYCLES_FRONTEND, QTest::StalledCycles }, |
| { 1350, PERF_TYPE_SOFTWARE, PERF_COUNT_SW_TASK_CLOCK, QTest::WalltimeMilliseconds }, |
| { 0, PERF_TYPE_MAX, 0, QTest::Events } |
| }; |
| /* -- END GENERATED CODE -- */ |
| |
| QTest::QBenchmarkMetric QBenchmarkPerfEventsMeasurer::metricForEvent(quint32 type, quint64 event_id) |
| { |
| const Events *ptr = eventlist; |
| for ( ; ptr->type != PERF_TYPE_MAX; ++ptr) { |
| if (ptr->type == type && ptr->event_id == event_id) |
| return ptr->metric; |
| } |
| return QTest::Events; |
| } |
| |
| void QBenchmarkPerfEventsMeasurer::setCounter(const char *name) |
| { |
| initPerf(); |
| const char *colon = strchr(name, ':'); |
| int n = colon ? colon - name : strlen(name); |
| const Events *ptr = eventlist; |
| for ( ; ptr->type != PERF_TYPE_MAX; ++ptr) { |
| int c = strncmp(name, eventlist_strings + ptr->offset, n); |
| if (c == 0) |
| break; |
| if (c < 0) { |
| fprintf(stderr, "ERROR: Performance counter type '%s' is unknown\n", name); |
| exit(1); |
| } |
| } |
| |
| attr.type = ptr->type; |
| attr.config = ptr->event_id; |
| |
| // now parse the attributes |
| if (!colon) |
| return; |
| while (*++colon) { |
| switch (*colon) { |
| case 'u': |
| attr.exclude_user = true; |
| break; |
| case 'k': |
| attr.exclude_kernel = true; |
| break; |
| case 'h': |
| attr.exclude_hv = true; |
| break; |
| case 'G': |
| attr.exclude_guest = true; |
| break; |
| case 'H': |
| attr.exclude_host = true; |
| break; |
| default: |
| fprintf(stderr, "ERROR: Unknown attribute '%c'\n", *colon); |
| exit(1); |
| } |
| } |
| } |
| |
| void QBenchmarkPerfEventsMeasurer::listCounters() |
| { |
| if (!isAvailable()) { |
| printf("Performance counters are not available on this system\n"); |
| return; |
| } |
| |
| printf("The following performance counters are available:\n"); |
| const Events *ptr = eventlist; |
| for ( ; ptr->type != PERF_TYPE_MAX; ++ptr) { |
| printf(" %-30s [%s]\n", eventlist_strings + ptr->offset, |
| ptr->type == PERF_TYPE_HARDWARE ? "hardware" : |
| ptr->type == PERF_TYPE_SOFTWARE ? "software" : |
| ptr->type == PERF_TYPE_HW_CACHE ? "cache" : "other"); |
| } |
| |
| printf("\nAttributes can be specified by adding a colon and the following:\n" |
| " u - exclude measuring in the userspace\n" |
| " k - exclude measuring in kernel mode\n" |
| " h - exclude measuring in the hypervisor\n" |
| " G - exclude measuring when running virtualized (guest VM)\n" |
| " H - exclude measuring when running non-virtualized (host system)\n" |
| "Attributes can be combined, for example: -perfcounter branch-mispredicts:kh\n"); |
| } |
| |
| QBenchmarkPerfEventsMeasurer::QBenchmarkPerfEventsMeasurer() = default; |
| |
| QBenchmarkPerfEventsMeasurer::~QBenchmarkPerfEventsMeasurer() |
| { |
| qt_safe_close(fd); |
| } |
| |
| void QBenchmarkPerfEventsMeasurer::init() |
| { |
| } |
| |
| void QBenchmarkPerfEventsMeasurer::start() |
| { |
| |
| initPerf(); |
| if (fd == -1) { |
| // pid == 0 -> attach to the current process |
| // cpu == -1 -> monitor on all CPUs |
| // group_fd == -1 -> this is the group leader |
| // flags == 0 -> reserved, must be zero |
| fd = perf_event_open(&attr, 0, -1, -1, 0); |
| if (fd == -1) { |
| perror("QBenchmarkPerfEventsMeasurer::start: perf_event_open"); |
| exit(1); |
| } else { |
| ::fcntl(fd, F_SETFD, FD_CLOEXEC); |
| } |
| } |
| |
| // enable the counter |
| ::ioctl(fd, PERF_EVENT_IOC_RESET); |
| ::ioctl(fd, PERF_EVENT_IOC_ENABLE); |
| } |
| |
| qint64 QBenchmarkPerfEventsMeasurer::checkpoint() |
| { |
| ::ioctl(fd, PERF_EVENT_IOC_DISABLE); |
| qint64 value = readValue(); |
| ::ioctl(fd, PERF_EVENT_IOC_ENABLE); |
| return value; |
| } |
| |
| qint64 QBenchmarkPerfEventsMeasurer::stop() |
| { |
| // disable the counter |
| ::ioctl(fd, PERF_EVENT_IOC_DISABLE); |
| return readValue(); |
| } |
| |
| bool QBenchmarkPerfEventsMeasurer::isMeasurementAccepted(qint64) |
| { |
| return true; |
| } |
| |
| int QBenchmarkPerfEventsMeasurer::adjustIterationCount(int) |
| { |
| return 1; |
| } |
| |
| int QBenchmarkPerfEventsMeasurer::adjustMedianCount(int) |
| { |
| return 1; |
| } |
| |
| QTest::QBenchmarkMetric QBenchmarkPerfEventsMeasurer::metricType() |
| { |
| return metricForEvent(attr.type, attr.config); |
| } |
| |
| static quint64 rawReadValue(int fd) |
| { |
| /* from the kernel docs: |
| * struct read_format { |
| * { u64 value; |
| * { u64 time_enabled; } && PERF_FORMAT_TOTAL_TIME_ENABLED |
| * { u64 time_running; } && PERF_FORMAT_TOTAL_TIME_RUNNING |
| * { u64 id; } && PERF_FORMAT_ID |
| * } && !PERF_FORMAT_GROUP |
| */ |
| |
| struct read_format { |
| quint64 value; |
| quint64 time_enabled; |
| quint64 time_running; |
| } results; |
| |
| size_t nread = 0; |
| while (nread < sizeof results) { |
| char *ptr = reinterpret_cast<char *>(&results); |
| qint64 r = qt_safe_read(fd, ptr + nread, sizeof results - nread); |
| if (r == -1) { |
| perror("QBenchmarkPerfEventsMeasurer::readValue: reading the results"); |
| exit(1); |
| } |
| nread += quint64(r); |
| } |
| |
| if (results.time_running == results.time_enabled) |
| return results.value; |
| |
| // scale the results, though this shouldn't happen! |
| return results.value * (double(results.time_running) / double(results.time_enabled)); |
| } |
| |
| qint64 QBenchmarkPerfEventsMeasurer::readValue() |
| { |
| quint64 raw = rawReadValue(fd); |
| if (metricType() == QTest::WalltimeMilliseconds) { |
| // perf returns nanoseconds |
| return raw / 1000000; |
| } |
| return raw; |
| } |
| |
| QT_END_NAMESPACE |
| |
| #endif |
