PerfSensorGroup.cpp

/*
 * PerfSensorGroup.cpp
 *
 *  Created on: 04.08.2018
 *      Author: Micha Mueller
 */

#include "PerfSensorGroup.h"

#include <unistd.h>
#include <sys/ioctl.h>
#include <linux/perf_event.h>
#include <linux/hw_breakpoint.h>
#include <asm/unistd.h>
#include <functional>
#include <limits.h>

//the read group data will have this format
struct read_format {
	uint64_t nr;
	struct {
		uint64_t value;
		uint64_t id;
	} values[];
};

PerfSensorGroup::PerfSensorGroup(const std::string& name) :
	SensorGroupTemplate(name),
	_sensorGroupLeader(false),
	_cpuId(0),
	_group_fd(-1),
	_bufSize(0) {
	_buf = nullptr;
}

PerfSensorGroup::~PerfSensorGroup() {
	if (_buf) {
		delete[] _buf;
	}
}

void PerfSensorGroup::init(boost::asio::io_service& io) {
	SensorGroupTemplate::init(io);

	//allocate buffer to read in later
	//requires 16 byte per sensor plus an additional 8 byte for a 64bit value
	std::size_t bufSize = _sensors.size() * 16 + 8;
	if (!_buf) {
		_buf = new char[bufSize];
		_bufSize = bufSize;
	} else if (bufSize > _bufSize) {
		delete _buf;
		_buf = new char[bufSize];
		_bufSize = bufSize;
	}

	if(!_sensorGroupLeader) {
		//only the sensorGroupLeader needs a timer
		_timer = nullptr;
	}
}

void PerfSensorGroup::start() {
	if (_keepRunning) {
		//we have been started already
		LOG(info) << "Sensorgroup " << _groupName << " already running.";
		return;
	}

	uint64_t id;

	//open perf-counters
	struct perf_event_attr pe;
	PerfSensorBase* pc = _sensors[0];

	memset(&pe, 0, sizeof(struct perf_event_attr));
	pe.size = sizeof(struct perf_event_attr);
	pe.type = pc->getType();
	pe.config = pc->getConfig();
	pe.disabled = 1;
	pe.exclude_kernel = 0;
	pe.exclude_hv = 1;
	pe.read_format = PERF_FORMAT_GROUP | PERF_FORMAT_ID;

	//perf_event_open() group leader
	_group_fd = syscall(__NR_perf_event_open, &pe, -1, _cpuId, -1, 0);
	ioctl(_group_fd, PERF_EVENT_IOC_ID, &id);
	//store ids to make them distinguishable when reading
	_ids.push_back(id);

	if (_group_fd == -1) {
		LOG(error) << "Failed to open performance-counter group \"" << _groupName << "\"";
		return;
	}
	LOG(debug) << "  " << _groupName << "::" << pc->getName() << " opened with ID " << std::to_string(id);

	pe.disabled = 0;
	//open all other counters attached to group leader
	for(unsigned i = 1; i < _sensors.size(); i++) {
		pc = _sensors[i];
		int fd;
		pe.type = pc->getType();
		pe.config = pc->getConfig();

		fd = syscall(__NR_perf_event_open, &pe, -1, _cpuId, _group_fd, 0);
		//store id, so that we can match counters with values later (see read())
		ioctl(fd, PERF_EVENT_IOC_ID, &id);
		_ids.push_back(id);
		_fds.push_back(fd);
		LOG(debug) << "  " << _groupName << "::" << pc->getName() << " opened with ID " << std::to_string(id);
	}

	ioctl(_group_fd, PERF_EVENT_IOC_RESET, 0);
	ioctl(_group_fd, PERF_EVENT_IOC_ENABLE, 0);

	_keepRunning = 1;
	if (_sensorGroupLeader) {
		_pendingTasks++;
		_timer->async_wait(std::bind(&PerfSensorGroup::readAsync, this));
	}
	LOG(info) << "Sensorgroup " << _groupName << " started.";
}

void PerfSensorGroup::stop() {
	_keepRunning = 0;
	if(_group_fd != -1) {
		for(auto& fd : _fds) {
			close(fd);
		}
		_ids.clear();
		_fds.clear();
		close(_group_fd);
		_group_fd = -1;
	}
	LOG(info) << "Sensorgroup " << _groupName << " stopped.";
}

void PerfSensorGroup::read() {
	reading_t reading;
	reading.timestamp = getTimestamp();

	struct read_format* rf = (struct read_format*) _buf;
	unsigned long long count;

	if (::read(_group_fd, _buf, _bufSize) < 0) {
		LOG(error) << "Sensorgroup" << _groupName << " could not read value";
		return;
	}

	//iterate over all values returned by ::read()
	for (unsigned i = 0; i < rf->nr; i++) {
		uint64_t val = rf->values[i].value;
		//iterate over all counters and find the one with matching id
		for (unsigned j = 0; j < _sensors.size(); j++) {
			if (rf->values[i].id == _ids[j]) {
				reading_t lV = _sensors[j]->getLatestValue();
				if (val >= lV.value) {
					reading.value = val - lV.value;
				} else {
					//the counter overflow since last read
					//according to perf_event_open() man-page u64 (=64bit) is used for event values
					//--> unsigned long long is usually also 64bit
					reading.value = val + (ULLONG_MAX - lV.value);
				}
#ifdef DEBUG
				LOG(debug) << _groupName << "::" << _sensors[j]->getName() << ": \"" << reading.value << "\"";
#endif
				_sensors[j]->storeReading(reading, _cacheIndex);
				break;
			}
		}
	}
	_cacheIndex = (_cacheIndex + 1) % _cacheSize;
}

void PerfSensorGroup::readAsync() {
	read();
	if(_sensorGroupLeader) {
		for(auto g : _fellowSensorGroups) {
			g->read();
		}
	}

	if (_timer && _keepRunning) {
		_timer->expires_at(timestamp2ptime(nextReadingTime()));
		_pendingTasks++;
		_timer->async_wait(std::bind(&PerfSensorGroup::readAsync, this));
	}
	_pendingTasks--;
}