diff options
Diffstat (limited to 'tools/gator/daemon/PerfDriver.cpp')
| -rw-r--r-- | tools/gator/daemon/PerfDriver.cpp | 355 |
1 files changed, 355 insertions, 0 deletions
diff --git a/tools/gator/daemon/PerfDriver.cpp b/tools/gator/daemon/PerfDriver.cpp new file mode 100644 index 000000000000..8e25c22f6798 --- /dev/null +++ b/tools/gator/daemon/PerfDriver.cpp @@ -0,0 +1,355 @@ +/** + * Copyright (C) ARM Limited 2013-2014. All rights reserved. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. + */ + +#include "PerfDriver.h" + +#include <dirent.h> +#include <sys/utsname.h> +#include <time.h> + +#include "Buffer.h" +#include "Config.h" +#include "ConfigurationXML.h" +#include "Counter.h" +#include "DriverSource.h" +#include "DynBuf.h" +#include "Logging.h" +#include "PerfGroup.h" +#include "SessionData.h" + +#define PERF_DEVICES "/sys/bus/event_source/devices" + +#define TYPE_DERIVED ~0U + +// From gator.h +struct gator_cpu { + const int cpuid; + // Human readable name + const char core_name[32]; + // gatorfs event and Perf PMU name + const char *const pmnc_name; + const int pmnc_counters; +}; + +// From gator_main.c +static const struct gator_cpu gator_cpus[] = { + { 0xb36, "ARM1136", "ARM_ARM11", 3 }, + { 0xb56, "ARM1156", "ARM_ARM11", 3 }, + { 0xb76, "ARM1176", "ARM_ARM11", 3 }, + { 0xb02, "ARM11MPCore", "ARM_ARM11MPCore", 3 }, + { 0xc05, "Cortex-A5", "ARMv7_Cortex_A5", 2 }, + { 0xc07, "Cortex-A7", "ARMv7_Cortex_A7", 4 }, + { 0xc08, "Cortex-A8", "ARMv7_Cortex_A8", 4 }, + { 0xc09, "Cortex-A9", "ARMv7_Cortex_A9", 6 }, + { 0xc0d, "Cortex-A12", "ARMv7_Cortex_A12", 6 }, + { 0xc0f, "Cortex-A15", "ARMv7_Cortex_A15", 6 }, + { 0xc0e, "Cortex-A17", "ARMv7_Cortex_A17", 6 }, + { 0x00f, "Scorpion", "Scorpion", 4 }, + { 0x02d, "ScorpionMP", "ScorpionMP", 4 }, + { 0x049, "KraitSIM", "Krait", 4 }, + { 0x04d, "Krait", "Krait", 4 }, + { 0x06f, "Krait S4 Pro", "Krait", 4 }, + { 0xd03, "Cortex-A53", "ARM_Cortex-A53", 6 }, + { 0xd07, "Cortex-A57", "ARM_Cortex-A57", 6 }, + { 0xd0f, "AArch64", "ARM_AArch64", 6 }, +}; + +static const char OLD_PMU_PREFIX[] = "ARMv7 Cortex-"; +static const char NEW_PMU_PREFIX[] = "ARMv7_Cortex_"; + +class PerfCounter { +public: + PerfCounter(PerfCounter *next, const char *name, uint32_t type, uint64_t config) : mNext(next), mName(name), mType(type), mCount(0), mKey(getEventKey()), mConfig(config), mEnabled(false) {} + ~PerfCounter() { + delete [] mName; + } + + PerfCounter *getNext() const { return mNext; } + const char *getName() const { return mName; } + uint32_t getType() const { return mType; } + int getCount() const { return mCount; } + void setCount(const int count) { mCount = count; } + int getKey() const { return mKey; } + uint64_t getConfig() const { return mConfig; } + void setConfig(const uint64_t config) { mConfig = config; } + bool isEnabled() const { return mEnabled; } + void setEnabled(const bool enabled) { mEnabled = enabled; } + +private: + PerfCounter *const mNext; + const char *const mName; + const uint32_t mType; + int mCount; + const int mKey; + uint64_t mConfig; + bool mEnabled; +}; + +PerfDriver::PerfDriver() : mCounters(NULL), mIsSetup(false) { +} + +PerfDriver::~PerfDriver() { + while (mCounters != NULL) { + PerfCounter *counter = mCounters; + mCounters = counter->getNext(); + delete counter; + } +} + +void PerfDriver::addCpuCounters(const char *const counterName, const int type, const int numCounters) { + int len = snprintf(NULL, 0, "%s_ccnt", counterName) + 1; + char *name = new char[len]; + snprintf(name, len, "%s_ccnt", counterName); + mCounters = new PerfCounter(mCounters, name, type, -1); + + for (int j = 0; j < numCounters; ++j) { + len = snprintf(NULL, 0, "%s_cnt%d", counterName, j) + 1; + name = new char[len]; + snprintf(name, len, "%s_cnt%d", counterName, j); + mCounters = new PerfCounter(mCounters, name, type, -1); + } +} + +// From include/generated/uapi/linux/version.h +#define KERNEL_VERSION(a,b,c) (((a) << 16) + ((b) << 8) + (c)) + +bool PerfDriver::setup() { + // Check the kernel version + struct utsname utsname; + if (uname(&utsname) != 0) { + logg->logMessage("%s(%s:%i): uname failed", __FUNCTION__, __FILE__, __LINE__); + return false; + } + + int release[3] = { 0, 0, 0 }; + int part = 0; + char *ch = utsname.release; + while (*ch >= '0' && *ch <= '9' && part < ARRAY_LENGTH(release)) { + release[part] = 10*release[part] + *ch - '0'; + + ++ch; + if (*ch == '.') { + ++part; + ++ch; + } + } + + if (KERNEL_VERSION(release[0], release[1], release[2]) < KERNEL_VERSION(3, 12, 0)) { + logg->logMessage("%s(%s:%i): Unsupported kernel version", __FUNCTION__, __FILE__, __LINE__); + return false; + } + + // Add supported PMUs + bool foundCpu = false; + DIR *dir = opendir(PERF_DEVICES); + if (dir == NULL) { + logg->logMessage("%s(%s:%i): opendif failed", __FUNCTION__, __FILE__, __LINE__); + return false; + } + + struct dirent *dirent; + while ((dirent = readdir(dir)) != NULL) { + for (int i = 0; i < ARRAY_LENGTH(gator_cpus); ++i) { + // Do the names match exactly? + if (strcmp(dirent->d_name, gator_cpus[i].pmnc_name) != 0 && + // Do these names match but have the old vs new prefix? + (strncmp(dirent->d_name, OLD_PMU_PREFIX, sizeof(OLD_PMU_PREFIX) - 1) != 0 || + strncmp(gator_cpus[i].pmnc_name, NEW_PMU_PREFIX, sizeof(NEW_PMU_PREFIX) - 1) != 0 || + strcmp(dirent->d_name + sizeof(OLD_PMU_PREFIX) - 1, gator_cpus[i].pmnc_name + sizeof(NEW_PMU_PREFIX) - 1) != 0)) { + continue; + } + + int type; + char buf[256]; + snprintf(buf, sizeof(buf), PERF_DEVICES "/%s/type", dirent->d_name); + if (DriverSource::readIntDriver(buf, &type) != 0) { + continue; + } + + foundCpu = true; + addCpuCounters(gator_cpus[i].pmnc_name, type, gator_cpus[i].pmnc_counters); + } + } + closedir(dir); + + if (!foundCpu) { + // If no cpu was found based on pmu names, try by cpuid + for (int i = 0; i < ARRAY_LENGTH(gator_cpus); ++i) { + if (gSessionData->mMaxCpuId != gator_cpus[i].cpuid) { + continue; + } + + foundCpu = true; + addCpuCounters(gator_cpus[i].pmnc_name, PERF_TYPE_RAW, gator_cpus[i].pmnc_counters); + } + } + + /* + if (!foundCpu) { + // If all else fails, use the perf architected counters + // 9 because that's how many are in events-Perf-Hardware.xml - assume they can all be enabled at once + addCpuCounters("Perf_Hardware", PERF_TYPE_HARDWARE, 9); + } + */ + + // Add supported software counters + long long id; + DynBuf printb; + + id = getTracepointId("irq/softirq_exit", &printb); + if (id >= 0) { + mCounters = new PerfCounter(mCounters, "Linux_irq_softirq", PERF_TYPE_TRACEPOINT, id); + } + + id = getTracepointId("irq/irq_handler_exit", &printb); + if (id >= 0) { + mCounters = new PerfCounter(mCounters, "Linux_irq_irq", PERF_TYPE_TRACEPOINT, id); + } + + //Linux_block_rq_wr + //Linux_block_rq_rd + //Linux_net_rx + //Linux_net_tx + + id = getTracepointId(SCHED_SWITCH, &printb); + if (id >= 0) { + mCounters = new PerfCounter(mCounters, "Linux_sched_switch", PERF_TYPE_TRACEPOINT, id); + } + + //Linux_meminfo_memused + //Linux_meminfo_memfree + //Linux_meminfo_bufferram + //Linux_power_cpu_freq + //Linux_power_cpu_idle + + mCounters = new PerfCounter(mCounters, "Linux_cpu_wait_contention", TYPE_DERIVED, -1); + + //Linux_cpu_wait_io + + mIsSetup = true; + return true; +} + +bool PerfDriver::summary(Buffer *const buffer) { + struct utsname utsname; + if (uname(&utsname) != 0) { + logg->logMessage("%s(%s:%i): uname failed", __FUNCTION__, __FILE__, __LINE__); + return false; + } + + char buf[512]; + snprintf(buf, sizeof(buf), "%s %s %s %s %s GNU/Linux", utsname.sysname, utsname.nodename, utsname.release, utsname.version, utsname.machine); + + struct timespec ts; + if (clock_gettime(CLOCK_REALTIME, &ts) != 0) { + logg->logMessage("%s(%s:%i): clock_gettime failed", __FUNCTION__, __FILE__, __LINE__); + return false; + } + const int64_t timestamp = (int64_t)ts.tv_sec * 1000000000L + ts.tv_nsec; + + if (clock_gettime(CLOCK_MONOTONIC, &ts) != 0) { + logg->logMessage("%s(%s:%i): clock_gettime failed", __FUNCTION__, __FILE__, __LINE__); + return false; + } + const int64_t uptime = (int64_t)ts.tv_sec * 1000000000L + ts.tv_nsec; + + buffer->summary(timestamp, uptime, 0, buf); + + for (int i = 0; i < gSessionData->mCores; ++i) { + int j; + for (j = 0; j < ARRAY_LENGTH(gator_cpus); ++j) { + if (gator_cpus[j].cpuid == gSessionData->mCpuIds[i]) { + break; + } + } + if (gator_cpus[j].cpuid == gSessionData->mCpuIds[i]) { + buffer->coreName(i, gSessionData->mCpuIds[i], gator_cpus[j].core_name); + } else { + snprintf(buf, sizeof(buf), "Unknown (0x%.3x)", gSessionData->mCpuIds[i]); + buffer->coreName(i, gSessionData->mCpuIds[i], buf); + } + } + buffer->commit(1); + + return true; +} + +PerfCounter *PerfDriver::findCounter(const Counter &counter) const { + for (PerfCounter * perfCounter = mCounters; perfCounter != NULL; perfCounter = perfCounter->getNext()) { + if (strcmp(perfCounter->getName(), counter.getType()) == 0) { + return perfCounter; + } + } + + return NULL; +} + +bool PerfDriver::claimCounter(const Counter &counter) const { + return findCounter(counter) != NULL; +} + +void PerfDriver::resetCounters() { + for (PerfCounter * counter = mCounters; counter != NULL; counter = counter->getNext()) { + counter->setEnabled(false); + } +} + +void PerfDriver::setupCounter(Counter &counter) { + PerfCounter *const perfCounter = findCounter(counter); + if (perfCounter == NULL) { + counter.setEnabled(false); + return; + } + + // Don't use the config from counters XML if it's not set, ex: software counters + if (counter.getEvent() != -1) { + perfCounter->setConfig(counter.getEvent()); + } + perfCounter->setCount(counter.getCount()); + perfCounter->setEnabled(true); + counter.setKey(perfCounter->getKey()); +} + +int PerfDriver::writeCounters(mxml_node_t *root) const { + int count = 0; + for (PerfCounter * counter = mCounters; counter != NULL; counter = counter->getNext()) { + mxml_node_t *node = mxmlNewElement(root, "counter"); + mxmlElementSetAttr(node, "name", counter->getName()); + ++count; + } + + return count; +} + +bool PerfDriver::enable(PerfGroup *group, Buffer *const buffer) const { + for (PerfCounter * counter = mCounters; counter != NULL; counter = counter->getNext()) { + if (counter->isEnabled() && (counter->getType() != TYPE_DERIVED)) { + if (!group->add(buffer, counter->getKey(), counter->getType(), counter->getConfig(), counter->getCount(), 0, 0)) { + logg->logMessage("%s(%s:%i): PerfGroup::add failed", __FUNCTION__, __FILE__, __LINE__); + return false; + } + } + } + + return true; +} + +long long PerfDriver::getTracepointId(const char *const name, DynBuf *const printb) { + if (!printb->printf(EVENTS_PATH "/%s/id", name)) { + logg->logMessage("%s(%s:%i): DynBuf::printf failed", __FUNCTION__, __FILE__, __LINE__); + return -1; + } + + int64_t result; + if (DriverSource::readInt64Driver(printb->getBuf(), &result) != 0) { + logg->logMessage("%s(%s:%i): DriverSource::readInt64Driver failed", __FUNCTION__, __FILE__, __LINE__); + return -1; + } + + return result; +} |