/**************************************************************************** ** ** 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 #include #include #include #include #include #include #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; } } /*! \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 \li sample tool: 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(0, 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 () { 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() : fd(-1) { } 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(&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