diff options
Diffstat (limited to 'src/cpu/kvm/perfevent.hh')
| -rw-r--r-- | src/cpu/kvm/perfevent.hh | 347 |
1 files changed, 347 insertions, 0 deletions
diff --git a/src/cpu/kvm/perfevent.hh b/src/cpu/kvm/perfevent.hh new file mode 100644 index 000000000..8242cc071 --- /dev/null +++ b/src/cpu/kvm/perfevent.hh @@ -0,0 +1,347 @@ +/* + * Copyright (c) 2012 ARM Limited + * All rights reserved + * + * The license below extends only to copyright in the software and shall + * not be construed as granting a license to any other intellectual + * property including but not limited to intellectual property relating + * to a hardware implementation of the functionality of the software + * licensed hereunder. You may use the software subject to the license + * terms below provided that you ensure that this notice is replicated + * unmodified and in its entirety in all distributions of the software, + * modified or unmodified, in source code or in binary form. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer; + * redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution; + * neither the name of the copyright holders nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * Authors: Andreas Sandberg + */ + +#ifndef __CPU_KVM_PERFEVENT_HH__ +#define __CPU_KVM_PERFEVENT_HH__ + +#include <linux/perf_event.h> +#include <sys/types.h> + +#include <inttypes.h> + +/** + * PerfEvent counter configuration. + */ +class PerfKvmCounterConfig +{ + public: + /** + * Initialize PerfEvent counter configuration structure + * + * PerfEvent has the concept of counter types, which is a way to + * abstract hardware performance counters or access software + * events. The type field in the configuration specifies what type + * of counter this is. For hardware performance counters, it's + * typically PERF_TYPE_HARDWARE, PERF_TYPE_HW_CACHE, or + * PERF_TYPE_RAW. + * + * The 'config' field has different meanings depending on the type + * of counter. Possible values are listed in perf_event.h in the + * kernel headers. When using raw counters, the value is the raw + * value written to the performance counter configuration register + * (some bits dealing with sampling and similar features are + * usually masked). + * + * @param type Counter type. + * @param config Counter configuration + */ + PerfKvmCounterConfig(uint32_t type, uint64_t config); + ~PerfKvmCounterConfig(); + + /** + * Set the initial sample period (overflow count) of an event. If + * this is set to 0, the event acts as a normal counting event and + * does not trigger overflows. + * + * @param period Number of counter events before the counter + * overflows + */ + PerfKvmCounterConfig &samplePeriod(uint64_t period) { + attr.freq = 0; + attr.sample_period = period; + return *this; + } + + /** + * Set the number of samples that need to be triggered before + * reporting data as being available on the perf event + * FD. Defaults to 0, which disables overflow reporting. + * + * @param events Number of overflows before signaling a wake up + */ + PerfKvmCounterConfig &wakeupEvents(uint32_t events) { + attr.watermark = 0; + attr.wakeup_events = events; + return *this; + } + + /** + * Don't start the performance counter automatically when + * attaching it. + * + * @param val true to disable, false to enable the counter + */ + PerfKvmCounterConfig &disabled(bool val) { + attr.disabled = val; + return *this; + } + + /** + * Force the group to be on the active all the time (i.e., + * disallow multiplexing). + * + * Only applies to group leaders. + * + * @param val true to pin the counter + */ + PerfKvmCounterConfig &pinned(bool val) { + attr.pinned = val; + return *this; + } + + /** Underlying perf_event_attr structure describing the counter */ + struct perf_event_attr attr; +}; + +/** + * An instance of a performance counter. + */ +class PerfKvmCounter +{ +public: + /** + * Create and attach a new counter group. + * + * @param config Counter configuration + * @param tid Thread to sample (0 indicates current thread) + */ + PerfKvmCounter(PerfKvmCounterConfig &config, pid_t tid); + /** + * Create and attach a new counter and make it a member of an + * exist counter group. + * + * @param config Counter configuration + * @param tid Thread to sample (0 indicates current thread) + * @param parent Group leader + */ + PerfKvmCounter(PerfKvmCounterConfig &config, + pid_t tid, const PerfKvmCounter &parent); + /** + * Create a new counter, but don't attach it. + */ + PerfKvmCounter(); + ~PerfKvmCounter(); + + + /** + * Attach a counter. + * + * @note This operation is only supported if the counter isn't + * already attached. + * + * @param config Counter configuration + * @param tid Thread to sample (0 indicates current thread) + */ + void attach(PerfKvmCounterConfig &config, pid_t tid) { + attach(config, tid, -1); + } + + /** + * Attach a counter and make it a member of an existing counter + * group. + * + * @note This operation is only supported if the counter isn't + * already attached. + * + * @param config Counter configuration + * @param tid Thread to sample (0 indicates current thread) + * @param parent Group leader + */ + void attach(PerfKvmCounterConfig &config, + pid_t tid, const PerfKvmCounter &parent) { + attach(config, tid, parent.fd); + } + + /** Detach a counter from PerfEvent. */ + void detach(); + + /** Check if a counter is attached. */ + bool attached() const { return fd != -1; } + + /** + * Start counting. + * + * @note If this counter is a group leader, it will start the + * entire group. + */ + void start(); + + /** + * Stop counting. + * + * @note If this counter is a group leader, it will stop the + * entire group. + */ + void stop(); + + /** + * Update the period of an overflow counter. + * + * @warning This ioctl has some pretty bizarre semantics. It seems + * like the new period isn't effective until after the next + * counter overflow. If you use this method to change the sample + * period, you will see one sample with the old period and then + * start sampling with the new period. + * + * @warning This method doesn't work at all on some 2.6.3x kernels + * since it has inverted check for the return value when copying + * parameters from userspace. + * + * @param period Overflow period in events + */ + void period(uint64_t period); + + /** + * Enable a counter for a fixed number of events. + * + * When this method is called, perf event enables the counter if + * it was disabled. It then leaves the counter enabled until it + * has overflowed a refresh times. + * + * @note This does not update the period of the counter. + * + * @param refresh Number of overflows before disabling the + * counter. + */ + void refresh(int refresh); + + /** + * Read the current value of a counter. + */ + uint64_t read() const; + + /** + * Enable signal delivery to a thread on counter overflow. + * + * @param tid Thread to deliver signal to + * @param signal Signal to send upon overflow + */ + void enableSignals(pid_t tid, int signal); + + /** + * Enable signal delivery on counter overflow. Identical to + * enableSignals(pid_t) when called with the current TID as its + * parameter. + * + * @param signal Signal to send upon overflow + */ + void enableSignals(int signal) { enableSignals(gettid(), signal); } + +private: + // Disallow copying + PerfKvmCounter(const PerfKvmCounter &that); + // Disallow assignment + PerfKvmCounter &operator=(const PerfKvmCounter &that); + + void attach(PerfKvmCounterConfig &config, pid_t tid, int group_fd); + + /** + * Get the TID of the current thread. + * + * @return Current thread's TID + */ + pid_t gettid(); + + /** + * MMAP the PerfEvent file descriptor. + * + * @note We currently don't use the ring buffer, but PerfEvent + * requires this to be mapped for overflow handling to work. + * + * @note Overflow handling requires at least one buf_page to be + * mapped. + * + * @param pages number of pages in circular sample buffer. Must be + * an even power of 2. + */ + void mmapPerf(int pages); + + /** @{ */ + /** + * PerfEvent fnctl interface. + * + * @param cmd fcntl command + * @param p1 Request parameter + * + * @return -1 on error (error number in errno), ioctl dependent + * value otherwise. + */ + int fcntl(int cmd, long p1); + int fcntl(int cmd, void *p1) { return fcntl(cmd, (long)p1); } + /** @} */ + + /** @{ */ + /** + * PerfEvent ioctl interface. + * + * @param request PerfEvent request + * @param p1 Optional request parameter + * + * @return -1 on error (error number in errno), ioctl dependent + * value otherwise. + */ + int ioctl(int request, long p1); + int ioctl(int request, void *p1) { return ioctl(request, (long)p1); } + int ioctl(int request) { return ioctl(request, 0L); } + /** @} */ + + /** + * Perform a read from the counter file descriptor. + * + * @param buf Destination buffer + * @param size Amount of data to read + */ + void read(void *buf, size_t size) const; + + /** + * PerfEvent file descriptor associated with counter. -1 if not + * attached to PerfEvent. + */ + int fd; + + /** Memory mapped PerfEvent sample ring buffer */ + struct perf_event_mmap_page *ringBuffer; + /** Total number of pages in ring buffer */ + int ringNumPages; + + /** Cached host page size */ + long pageSize; +}; + +#endif |