Commit 5d4b2271 authored by Carla Guillen Carias's avatar Carla Guillen Carias
Browse files

Developing derived metrics

parent b5278b79
......@@ -10,7 +10,8 @@ streaming true
}
supermucngperf cpi {
default def1
default def1
measurement_interval 10000
input {
sensor "<bottomup>clocks"{
position 0
......
......@@ -10,6 +10,18 @@
#include "cacheentry.h"
template<typename ...Args>
bool getTimestampFromReadings(uint64_t & timestamp, Args&...args){
reading_t readings[] = {args...};
for(auto & reading: readings){
if(reading.timestamp != 0){
timestamp = reading.timestamp;
return true;
}
}
return false;
}
/**
* For CPI, LoadsToStore, Branch rate, miss branch ratio, etc..
*/
......@@ -17,8 +29,7 @@ bool calculateMetricRatio(reading_t & dividend, reading_t & divisor,
unsigned int scaling_factor, reading_t & result) {
if(divisor.value > 0){
result.value = (dividend.value / static_cast<float>(divisor.value))*scaling_factor;
result.timestamp = dividend.timestamp;
return true;
return getTimestampFromReadings(result.timestamp, dividend, divisor);
}
return false; //Division by zero
}
......@@ -27,8 +38,7 @@ bool calculateMetricRatio(reading_t & dividend, reading_t & divisor,
bool calculateMetricPerSec(reading_t & metric, uint64_t interval, unsigned int scaling_factor, reading_t & result) {
if(interval > 0) {
result.value = (metric.value / static_cast<float>(interval))*scaling_factor;
result.timestamp = metric.timestamp;
return true;
return getTimestampFromReadings(result.timestamp, metric);
}
return false; //Division by zero
}
......@@ -40,7 +50,7 @@ bool calculateFrequency(reading_t & unhaltedRef, reading_t & unhaltedClocks,
if(result.value > (max_freq * 1.1) || result.value < (min_freq*0.9)) { //There is something wrong here...
return false;
}
return true;
return getTimestampFromReadings(result.timestamp, unhaltedRef, unhaltedClocks);
}
return false; //Division by zero
}
......
......@@ -28,24 +28,28 @@
#include "SKXPMUMetrics.h"
#include <cstdint>
#include "../../includes/DerivedMetrics.h"
#include "../../../common/include/cacheentry.h"
bool calculateFlops(reading_t &scalarDB, reading_t & scalarSP,
reading_t & packedDP128, reading_t & packedSP128,
reading_t & packedDP256, reading_t & packedSP256,
reading_t & packedDP512, reading_t & packedSP512,
uint64_t interval, reading_t & result) {
if(interval > 0 ){
result.value = (packedDP128.value * 2 + packedSP128.value * 4
+ packedDP256.value * 4 + packedSP256.value * 8
+ packedDP512.value * 8 + packedSP512.value * 16 + scalarDB.value
+ scalarSP.value)/ static_cast<float>(interval);
result.timestamp = packedDP128.timestamp;
return true;
}
return false;
reading_t & packedDP128, reading_t & packedSP128,
reading_t & packedDP256, reading_t & packedSP256,
reading_t & packedDP512, reading_t & packedSP512, reading_t & result) {
result.value = (packedDP128.value * 2 + packedSP128.value * 4
+ packedDP256.value * 4 + packedSP256.value * 8
+ packedDP512.value * 8 + packedSP512.value * 16 + scalarDB.value
+ scalarSP.value);
return getTimestampFromReadings(result.timestamp, scalarDB, scalarSP, packedDP128, packedSP128, packedDP256, packedSP256, packedDP512, packedSP512);
}
bool calculatePackedFlops(reading_t & packedDP128, reading_t & packedSP128,
reading_t & packedDP256, reading_t & packedSP256,
reading_t & packedDP512, reading_t & packedSP512,
reading_t & result) {
result.value = (packedDP128.value * 2 + packedSP128.value * 4
+ packedDP256.value * 4 + packedSP256.value * 8
+ packedDP512.value * 8 + packedSP512.value * 16);
return getTimestampFromReadings(result.timestamp, packedDP128, packedSP128, packedDP256, packedSP256, packedDP512, packedSP512);
}
bool calculateVectorizationRate(reading_t & scalarDB, reading_t & scalarSP,
......@@ -59,8 +63,41 @@ bool calculateVectorizationRate(reading_t & scalarDB, reading_t & scalarSP,
if(denominator > 0 ){
result.value = (packedDP128.value + packedSP128.value + packedDP256.value
+ packedSP256.value + packedDP256.value + packedSP512.value + packedDP512.value)/denominator;
result.timestamp = scalarDB.timestamp;
return true;
return getTimestampFromReadings(result.timestamp, scalarDB, scalarSP,
packedDP128, packedSP128, packedDP256, packedSP256, packedDP512,
packedSP512);
}
return false;
}
bool calculateAVX512FlopsToVectorizedRatio(reading_t & packedDP128, reading_t & packedSP128,
reading_t & packedDP256, reading_t & packedSP256,
reading_t & packedDP512, reading_t & packedSP512,
reading_t & result){
float denominator = static_cast<float>(packedDP128.value + packedSP128.value +
packedDP256.value + packedSP256.value +
packedDP512.value + packedSP512.value);
if(denominator > 0){
result.value = (packedDP512.value * 8 + packedSP512.value * 16)/denominator;
return getTimestampFromReadings(result.timestamp, packedDP128, packedSP128, packedDP256, packedSP256, packedDP512, packedSP512);
}
return false;
}
bool calculateSP_TO_TOTAL_RATIO(reading_t &scalarDB, reading_t & scalarSP,
reading_t & packedDP128, reading_t & packedSP128,
reading_t & packedDP256, reading_t & packedSP256,
reading_t & packedDP512, reading_t & packedSP512,
reading_t & result){
auto single_precision = packedSP128.value * 4 + packedSP256.value * 8
+ packedSP512.value * 16 + scalarSP.value;
float total = single_precision = packedDP128.value * 2 + packedDP256.value * 4 + packedDP512.value * 8 + scalarDB.value;
if(total > 0){
result.value = single_precision/total;
return getTimestampFromReadings(result.timestamp, scalarDB, scalarSP,
packedDP128, packedSP128, packedDP256, packedSP256, packedDP512,
packedSP512);
}
return false;
}
......@@ -68,8 +105,13 @@ bool calculateVectorizationRate(reading_t & scalarDB, reading_t & scalarSP,
bool calculateMemoryBandwidth(std::vector<reading_t> membw_counts, reading_t & result) {
result.value = 0;
const unsigned int SIZEPERACCESS = 64;
bool ret_val = false;
for(auto &rt : membw_counts){
result.value += rt.value * SIZEPERACCESS;
if(rt.timestamp != 0){
result.timestamp = rt.timestamp;
ret_val = true;
}
}
return true;
return ret_val;
}
......@@ -34,13 +34,30 @@ bool calculateFlops(reading_t &scalarDB, reading_t & scalarSP,
reading_t & packedDP128, reading_t & packedSP128,
reading_t & packedDP256, reading_t & packedSP256,
reading_t & packedDP512, reading_t & packedSP512,
uint64_t interval, reading_t & result);
reading_t & result);
bool calculateVectorizationRate(reading_t & scalarDB, reading_t & scalarSP,
bool calculatePackedFlops(reading_t & packedDP128, reading_t & packedSP128,
reading_t & packedDP256, reading_t & packedSP256,
reading_t & packedDP512, reading_t & packedSP512,
reading_t & result);
bool calculateVectorizationRatio(reading_t & scalarDB, reading_t & scalarSP,
reading_t & packedDP128, reading_t & packedSP128,
reading_t & packedDP256, reading_t & packedSP256,
reading_t & packedDP512, reading_t & packedSP512, reading_t & result);
bool calculateAVX512FlopsToVectorizedRatio(reading_t & packedDP128, reading_t & packedSP128,
reading_t & packedDP256, reading_t & packedSP256,
reading_t & packedDP512, reading_t & packedSP512,
reading_t & result);
bool calculateSP_TO_TOTAL_RATIO(reading_t &scalarDB, reading_t & scalarSP,
reading_t & packedDP128, reading_t & packedSP128,
reading_t & packedDP256, reading_t & packedSP256,
reading_t & packedDP512, reading_t & packedSP512,
reading_t & result);
bool calculateMemoryBandwidth(std::vector<reading_t> membw_counts, reading_t & result);
#endif /* ANALYTICS_ANALYZERS_SMUCNGPERFANALYZER_SKXDERIVEDMETRICS_SKXPMUMETRICS_H_ */
......@@ -67,6 +67,13 @@ void SMUCNGPerfConfigurator::sensorBase(SMUCSensorBase& s, CFG_VAL config) {
void SMUCNGPerfConfigurator::operatorAttributes(SMUCNGPerfOperator& op, CFG_VAL config){
op.setMetricToPosition(_metricToPosition);
/*BOOST_FOREACH(boost::property_tree::iptree::value_type &val, config)
{
if (boost::iequals(val.first, "measurement_interval")){
auto measurementInterval = stoull(val.second.data()) * 1000000;
op.setMeasurementInterval(measurementInterval);
}
}*/
}
bool SMUCNGPerfConfigurator::unit(UnitTemplate<SMUCSensorBase>& u) {
......
......@@ -25,26 +25,47 @@
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
//================================================================================
#include "../../includes/DerivedMetrics.h"
#include "SMUCNGPerfOperator.h"
#include <boost/log/sources/record_ostream.hpp>
#include <boost/log/utility/formatting_ostream.hpp>
#include <boost/parameter/keyword.hpp>
#include <cstdint>
#include <memory>
#include <string>
#include <utility>
#include <vector>
#include "../../../common/include/cacheentry.h"
#include "../../../common/include/logging.h"
#include "../../../common/include/sensorbase.h"
#include "../../../common/include/timestamp.h"
#include "../../includes/DerivedMetrics.h"
#include "../../includes/QueryEngine.h"
#include "../../includes/UnitTemplate.h"
#include "SKXPMUMetrics.h"
SMUCNGPerfOperator::SMUCNGPerfOperator(const std::string& name): OperatorTemplate(name) {
_buffers.resize(10);
_buffers.resize(64);
}
SMUCNGPerfOperator::~SMUCNGPerfOperator() {
}
SMUCNGPerfOperator::SMUCNGPerfOperator(const SMUCNGPerfOperator& other) : OperatorTemplate(other){
this->_buffers = other._buffers;
this->_metricToPosition = other._metricToPosition;
copy(other);
}
SMUCNGPerfOperator& SMUCNGPerfOperator::operator=(const SMUCNGPerfOperator& other){
OperatorTemplate::operator =(other);
copy(other);
return *this;
}
void SMUCNGPerfOperator::copy(const SMUCNGPerfOperator& other){
this->_buffers = other._buffers;
this->_metricToPosition = other._metricToPosition;
return *this;
//this->_measurement_interval = other._measurement_interval;
}
void SMUCNGPerfOperator::printConfig(LOG_LEVEL ll) {
......@@ -60,24 +81,13 @@ void SMUCNGPerfOperator::compute(U_Ptr unit) {
auto timestamp = getTimestamp() - 10e9 ; //ToDo timestamp minus some time...
for(auto& outSensor : unit->getOutputs()){
if( outSensor->getMetric() == SMUCSensorBase::CPI) {
std::vector<reading_t> & instructions = _buffers[0];
std::vector<reading_t> & clocks = _buffers[1];
query(inputs[_metricToPosition[SMUCSensorBase::INSTRUCTIONS]]->getName(), timestamp, instructions);
query(inputs[_metricToPosition[SMUCSensorBase::CLOCKS]]->getName(), timestamp, clocks);
bool wascalced = false;
reading_t cpi;
if (instructions.size() > 0 && clocks.size() > 0 && calculateMetricRatio(clocks[0], instructions[0], outSensor->getScalingFactor(), cpi)) {
outSensor->storeReading(cpi);
}
computeCPI(inputs, outSensor, timestamp);
} else if (outSensor->getMetric() == SMUCSensorBase::FREQUENCY) {
std::vector<reading_t> & clocks = _buffers[0];
std::vector<reading_t> & clocks_ref = _buffers[1];
query(inputs[_metricToPosition[SMUCSensorBase::CLOCKS]]->getName(), timestamp, clocks);
query(inputs[_metricToPosition[SMUCSensorBase::CLOCKS_REF]]->getName(), timestamp, clocks_ref);
reading_t frequency;
if( clocks.size() > 0 && clocks_ref.size() > 0 && calculateFrequency(clocks_ref[0],clocks[0], MIN_FREQ_MHZ, MAX_FREQ_MHZ, frequency)) {
outSensor->storeReading(frequency);
}
computeFREQUENCY(inputs, outSensor, timestamp);
} else if (outSensor->getMetric() == SMUCSensorBase::FLOPS || outSensor->getMetric() == SMUCSensorBase::PACKED_FLOPS ||
outSensor->getMetric() == SMUCSensorBase::AVX512_TOVECTORIZED_RATIO || outSensor->getMetric() == SMUCSensorBase::VECTORIZED_RATIO ||
outSensor->getMetric() == SMUCSensorBase::SINGLE_PRECISION_TO_TOTAL_RATIO) {
computeFLOPS(inputs, outSensor, timestamp);
}
resetBuffers();
}
......@@ -92,3 +102,128 @@ void SMUCNGPerfOperator::resetBuffers(){
buffer.clear();
}
}
void SMUCNGPerfOperator::computeCPI(std::vector<SMUCNGPtr>& inputs, SMUCNGPtr &outSensor, const uint64_t timestamp){
std::vector<reading_t> & instructions = _buffers[0];
std::vector<reading_t> & clocks = _buffers[1];
query(inputs[_metricToPosition[SMUCSensorBase::INSTRUCTIONS]]->getName(), timestamp, instructions);
query(inputs[_metricToPosition[SMUCSensorBase::CLOCKS]]->getName(), timestamp, clocks);
bool wascalced = false;
reading_t cpi;
if (instructions.size() > 0 && clocks.size() > 0 && calculateMetricRatio(clocks[0], instructions[0], outSensor->getScalingFactor(), cpi)) {
outSensor->storeReading(cpi);
}
}
void SMUCNGPerfOperator::computeFREQUENCY(std::vector<SMUCNGPtr>& inputs, SMUCNGPtr& outSensor, const uint64_t timestamp) {
std::vector<reading_t> & clocks = _buffers[0];
std::vector<reading_t> & clocks_ref = _buffers[1];
query(inputs[_metricToPosition[SMUCSensorBase::CLOCKS]]->getName(), timestamp, clocks);
query(inputs[_metricToPosition[SMUCSensorBase::CLOCKS_REF]]->getName(), timestamp, clocks_ref);
reading_t frequency;
if( clocks.size() > 0 && clocks_ref.size() > 0 && calculateFrequency(clocks_ref[0],clocks[0], MIN_FREQ_MHZ, MAX_FREQ_MHZ, frequency)) {
outSensor->storeReading(frequency);
}
}
void SMUCNGPerfOperator::computeFLOPS(std::vector<SMUCNGPtr>& inputs, SMUCNGPtr& outSensor, const uint64_t timestamp) {
SMUCSensorBase::Metric_t flop_metric = outSensor->getMetric();
std::vector<reading_t> & fp_arith_scalar_double = _buffers[0];
std::vector<reading_t> & fp_arith_scalar_single = _buffers[1];
std::vector<reading_t> & fp_arith_128b_packed_double = _buffers[2];
std::vector<reading_t> & fp_arith_128b_packed_single = _buffers[3];
std::vector<reading_t> & fp_arith_256b_packed_double = _buffers[4];
std::vector<reading_t> & fp_arith_256b_packed_single = _buffers[5];
std::vector<reading_t> & fp_arith_512b_packed_double = _buffers[6];
std::vector<reading_t> & fp_arith_512b_packed_single = _buffers[7];
query(inputs[_metricToPosition[SMUCSensorBase::FP_ARITH_SCALAR_DOUBLE]]->getName(), timestamp, fp_arith_scalar_double);
query(inputs[_metricToPosition[SMUCSensorBase::FP_ARITH_SCALAR_SINGLE]]->getName(), timestamp, fp_arith_scalar_single);
query(inputs[_metricToPosition[SMUCSensorBase::FP_ARITH_128B_PACKED_DOUBLE]]->getName(), timestamp, fp_arith_128b_packed_double);
query(inputs[_metricToPosition[SMUCSensorBase::FP_ARITH_128B_PACKED_SINGLE]]->getName(), timestamp, fp_arith_128b_packed_single);
query(inputs[_metricToPosition[SMUCSensorBase::FP_ARITH_256B_PACKED_DOUBLE]]->getName(), timestamp, fp_arith_256b_packed_double);
query(inputs[_metricToPosition[SMUCSensorBase::FP_ARITH_256B_PACKED_SINGLE]]->getName(), timestamp, fp_arith_256b_packed_single);
query(inputs[_metricToPosition[SMUCSensorBase::FP_ARITH_512B_PACKED_DOUBLE]]->getName(), timestamp, fp_arith_512b_packed_double);
query(inputs[_metricToPosition[SMUCSensorBase::FP_ARITH_512B_PACKED_SINGLE]]->getName(), timestamp, fp_arith_512b_packed_single);
reading_t empty;
empty.value = 0;
empty.timestamp = 0;
reading_t & scalar_double = fp_arith_scalar_double.size() > 0 ? fp_arith_scalar_double[0]: empty;
reading_t & scalar_single = fp_arith_scalar_single.size() > 0 ? fp_arith_scalar_single[0]: empty;
reading_t & packed128_double = fp_arith_128b_packed_double.size() > 0 ? fp_arith_128b_packed_double[0] : empty;
reading_t & packed128_single = fp_arith_128b_packed_single.size() > 0 ? fp_arith_128b_packed_single[0] : empty;
reading_t & packed256_double = fp_arith_256b_packed_double.size() > 0 ? fp_arith_256b_packed_double[0] : empty;
reading_t & packed256_single = fp_arith_256b_packed_single.size() > 0 ? fp_arith_256b_packed_single[0] : empty;
reading_t & packed512_double = fp_arith_512b_packed_double.size() > 0 ? fp_arith_512b_packed_double[0] :empty;
reading_t & packed512_single = fp_arith_512b_packed_single.size() > 0 ? fp_arith_512b_packed_single[0] : empty;
reading_t result;
if(flop_metric == SMUCSensorBase::FLOPS) {
if (calculateFlops(scalar_double, scalar_single, packed128_double,
packed128_single, packed256_double, packed256_single,
packed512_double, packed512_single, result) ) {
outSensor->storeReading(result);
}
} else if(flop_metric == SMUCSensorBase::PACKED_FLOPS){
if(calculatePackedFlops(packed128_double,packed128_single,packed256_double,packed256_single,packed512_double,packed512_single, result)){
outSensor->storeReading(result);
}
} else if(flop_metric == SMUCSensorBase::VECTORIZED_RATIO) {
if(calculateVectorizationRatio(scalar_double, scalar_single, packed128_double,
packed128_single, packed256_double, packed256_single,
packed512_double, packed512_single, result)) {
outSensor->storeReading(result);
}
} else if (flop_metric == SMUCSensorBase::AVX512_TOVECTORIZED_RATIO) {
if (calculateAVX512FlopsToVectorizedRatio(packed128_double,
packed128_single, packed256_double, packed256_single,
packed512_double, packed512_single, result)) {
outSensor->storeReading(result);
}
} else if (flop_metric == SMUCSensorBase::SINGLE_PRECISION_TO_TOTAL_RATIO) {
if(calculateSP_TO_TOTAL_RATIO(scalar_double, scalar_single, packed128_double,
packed128_single, packed256_double, packed256_single,
packed512_double, packed512_single, result)){
outSensor->storeReading(result);
}
}
}
/*void SMUCNGPerfOperator::computeINSTR_INTRA_NODE_LOADIMBALANCE(std::vector<SMUCNGPtr>& inputs,
SMUCNGPtr& outSensor, const uint64_t timestamp) {
}*/
void SMUCNGPerfOperator::computeL3_TO_INSTRUCTIONS_RATIO(std::vector<SMUCNGPtr>& inputs, SMUCNGPtr& outSensor,
const uint64_t timestamp) {
}
void SMUCNGPerfOperator::computeL3_BANDWIDTH(std::vector<SMUCNGPtr>& inputs, SMUCNGPtr& outSensor,
const uint64_t timestamp) {
}
void SMUCNGPerfOperator::computeL3HIT_TO_L3MISS_RATIO(std::vector<SMUCNGPtr>& inputs, SMUCNGPtr& outSensor,
const uint64_t timestamp) {
}
void SMUCNGPerfOperator::computeLOADS_TO_STORES(std::vector<SMUCNGPtr>& inputs, SMUCNGPtr& outSensor,
const uint64_t timestamp) {
}
void SMUCNGPerfOperator::computeLOADS_TOL3MISS_RATIO(std::vector<SMUCNGPtr>& inputs, SMUCNGPtr& outSensor,
const uint64_t timestamp) {
}
void SMUCNGPerfOperator::computeBRANCH_PER_INSTRUCTIONS(std::vector<SMUCNGPtr>& inputs, SMUCNGPtr& outSensor) {
}
void SMUCNGPerfOperator::computeMISSBRANCHES_TO_TOTAL_BRANCH_RATIO(std::vector<SMUCNGPtr>& inputs,
SMUCNGPtr& outSensor, const uint64_t timestamp) {
}
void SMUCNGPerfOperator::computeMEMORY_BANDWIDTH(std::vector<SMUCNGPtr>& inputs, SMUCNGPtr& outSensor,
const uint64_t timestamp) {
}
......@@ -33,9 +33,6 @@
#include <map>
class SMUCNGPerfOperator: virtual public OperatorTemplate<SMUCSensorBase>{
private:
std::map<SMUCSensorBase::Metric_t, unsigned int> _metricToPosition;
public:
SMUCNGPerfOperator(const std::string& name);
virtual ~SMUCNGPerfOperator();
......@@ -47,14 +44,45 @@ public:
_metricToPosition = metricToPosition;
}
/* void setMeasurementInterval(unsigned int measurement_interval){
_measurement_interval = measurement_interval;
}*/
protected:
virtual void compute(U_Ptr unit) override;
std::map<SMUCSensorBase::Metric_t, unsigned int> _metricToPosition;
vector<vector<reading_t>> _buffers;
const unsigned int MAX_FREQ_MHZ = 2700;
const unsigned int MIN_FREQ_MHZ = 1200;
//unsigned int _measurement_interval;
virtual void compute(U_Ptr unit) override;
void resetBuffers();
void query(const std::string & sensor_name, const uint64_t timestamp, vector<reading_t> &buffer);
void copy(const SMUCNGPerfOperator& other);
void computeCPI(std::vector<SMUCNGPtr>& inputs, SMUCNGPtr &outSensor, const uint64_t timestamp);
void computeFREQUENCY(std::vector<SMUCNGPtr>& inputs, SMUCNGPtr &outSensor, const uint64_t timestamp);
//void computeINSTRUCTIONS_PER_SECOND(SMUCNGPtr &outSensor, const uint64_t timestamp);
void computeFLOPS(std::vector<SMUCNGPtr>& inputs, SMUCNGPtr &outSensor, const uint64_t timestamp);
void computeEXPENSIVE_INSTRUCTIONS_PER_SECOND(std::vector<SMUCNGPtr>& inputs, SMUCNGPtr &outSensor, const uint64_t timestamp);
//void computeINSTR_INTRA_NODE_LOADIMBALANCE(std::vector<SMUCNGPtr>& inputs, SMUCNGPtr &outSensor, const uint64_t timestamp);
//void computeINSTR_INTER_NODE_LOADIMBALANCE((SMUCNGPtr &outSensor); //needs to be donejob plugin
//void computeL2_HITS_PER_SECOND(SMUCNGPtr &outSensor, const uint64_t timestamp);
//void computeL2_MISSES_PER_SECOND(SMUCNGPtr &outSensor, const uint64_t timestamp);
//void computeL3_HITS_PER_SECOND(SMUCNGPtr &outSensor, const uint64_t timestamp);
//void computeL3_MISSES_PER_SECOND(SMUCNGPtr &outSensor, const uint64_t timestamp);
void computeL3_TO_INSTRUCTIONS_RATIO(std::vector<SMUCNGPtr>& inputs, SMUCNGPtr &outSensor, const uint64_t timestamp);
void computeL3_BANDWIDTH(std::vector<SMUCNGPtr>& inputs, SMUCNGPtr &outSensor, const uint64_t timestamp);
void computeL3HIT_TO_L3MISS_RATIO(std::vector<SMUCNGPtr>& inputs, SMUCNGPtr &outSensor, const uint64_t timestamp);
void computeLOADS_TO_STORES(std::vector<SMUCNGPtr>& inputs, SMUCNGPtr &outSensor, const uint64_t timestamp);
void computeLOADS_TOL3MISS_RATIO(std::vector<SMUCNGPtr>& inputs, SMUCNGPtr &outSensor, const uint64_t timestamp);
//void computeMISSBRANCHES_PER_SECOND(SMUCNGPtr &outSensor, const uint64_t timestamp);
void computeBRANCH_PER_INSTRUCTIONS(std::vector<SMUCNGPtr>& inputs, SMUCNGPtr &outSensor);
void computeMISSBRANCHES_TO_TOTAL_BRANCH_RATIO(std::vector<SMUCNGPtr>& inputs, SMUCNGPtr &outSensor, const uint64_t timestamp);
void computeMEMORY_BANDWIDTH(std::vector<SMUCNGPtr>& inputs, SMUCNGPtr &outSensor, const uint64_t timestamp);
};
#endif /* ANALYTICS_SMUCNGPERF_SMUCNGPERFOPERATOR_H_ */
......@@ -36,8 +36,86 @@ public:
INSTRUCTIONS,
CLOCKS,
CLOCKS_REF,
USERPCT,
SYSTEMPCT,
IOWAITPCT,
MEMINFO,
IOBYTESREAD,
IOBYTESWRITE,
IOOPENS,
IOCLOSES,
IOREADS,
IOWRITES,
NETWORK_XMIT,
NETWORK_RCVD,
NETWORK_XMIT_PKTS,
NETWORK_RCVD_PKTS,
L2_RQSTS_MISS,
ARITH_FPU_DIVIDER_ACTIVE,
FP_ARITH_SCALAR_DOUBLE,
FP_ARITH_SCALAR_SINGLE,
FP_ARITH_128B_PACKED_DOUBLE,
FP_ARITH_128B_PACKED_SINGLE,
FP_ARITH_256B_PACKED_DOUBLE,
FP_ARITH_256B_PACKED_SINGLE,
FP_ARITH_512B_PACKED_DOUBLE,
FP_ARITH_512B_PACKED_SINGLE,
MEM_INST_RETIRED_ALL_LOADS,
MEM_INST_RETIRED_ALL_STORES,
PERF_COUNT_HW_CACHE_REFERENCES,
PERF_COUNT_HW_CACHE_MISSES,
PERF_COUNT_HW_BRANCH_INSTRUCTIONS,
PERF_COUNT_HW_BRANCH_MISSES,
CORE_TEMPERATURE,
//
CPI,
FREQUENCY,
INSTRUCTIONS_PER_SECOND,
FLOPS,
PACKED_FLOPS,
AVX512_TOVECTORIZED_RATIO, //AVX512/(TOTAL VECTORIZED)
VECTORIZED_RATIO, //(TOTAL VECTORIZED)/(ALL FLOPS)
SINGLE_PRECISION_TO_TOTAL_RATIO, //Flops
EXPENSIVE_INSTRUCTIONS_PER_SECOND,
INSTR_INTRA_NODE_LOADIMBALANCE,
INSTR_INTER_NODE_LOADIMBALANCE,
L2_HITS_PER_SECOND,
L2_MISSES_PER_SECOND,
L3_HITS_PER_SECOND,
L3_MISSES_PER_SECOND,
L3_TO_INSTRUCTIONS_RATIO,
L3_BANDWIDTH,
L3HIT_TO_L3MISS_RATIO,
LOADS_TO_STORES,
LOADS_TOL3MISS_RATIO,
MISSBRANCHES_PER_SECOND,
BRANCH_PER_INSTRUCTIONS,
MISSBRANCHES_TO_TOTAL_BRANCH_RATIO,
MEMORY_BANDWIDTH,
RAPL_PKG,
RAPL_MEM,
IPMI_CPU,
IPMI_MEM,
IPMI_DC,
IPMI_AC,
NETWORK_XMIT_BYTES_PER_OP,
NETWORK_BYTES_XMIT_PER_SECOND,
NETWORK_RCV_BYTES_PER_OP,
NETWORK_BYTES_RCVD_PER_SECOND,
IOOPENS_PER_SECOND,
IOCLOSES_PER_SECOND,
IOBYTESREAD_PER_SECOND,
IOBYTESWRITE_PER_SECOND,
IOREADS_PER_SECOND,
IOWRITES_PER_SECOND,
IO_BYTES_READ_PER_OP,
IO_BYTES_WRITE_PER_OP,
IOBYTESREAD_PER_SECOND_PROF,
IOBYTESWRITE_PER_SECOND_PROF,
IOREADS_PER_SECOND_PROF,
IOWRITES_PER_SECOND_PROF,
IO_BYTES_READ_PER_OP_PROF,
IO_BYTES_WRITE_PER_OP_PROF,
NONE
};
public:
......
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment