SMUCNGPerfOperator.cpp 18.2 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
//================================================================================
// Name        : SMUCNGPerfOperator.cpp
// Author      : Carla Guillen
// Contact     : info@dcdb.it
// Copyright   : Leibniz Supercomputing Centre
// Description : Template implementing features to use Units in Operators.
//================================================================================

//================================================================================
// This file is part of DCDB (DataCenter DataBase)
// Copyright (C) 2018-2019 Leibniz Supercomputing Centre
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
//================================================================================
27

28
#include "SMUCNGPerfOperator.h"
29

30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46
#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/QueryEngine.h"
#include "../../includes/UnitTemplate.h"
#include "SKXPMUMetrics.h"

Carla Guillen's avatar
Carla Guillen committed
47
SMUCNGPerfOperator::SMUCNGPerfOperator(const std::string& name): OperatorTemplate(name), _go_back_ns(0), _measuring_interval_s(1) {
48
    _buffers.resize(64);
49 50
    _metricPerSecToId[SMUCSensorBase::INSTRUCTIONS_PER_SECOND] = SMUCSensorBase::INSTRUCTIONS;
    _metricPerSecToId[SMUCSensorBase::EXPENSIVE_INSTRUCTIONS_PER_SECOND] = SMUCSensorBase::ARITH_FPU_DIVIDER_ACTIVE;
Carla Guillen's avatar
Carla Guillen committed
51
//    _metricToPerSecId[SMUCSensorBase::L2_HITS] = SMUCSensorBase::L2_HITS_PER_SECOND;
52 53 54 55
    _metricPerSecToId[SMUCSensorBase::L2_MISSES_PER_SECOND] = SMUCSensorBase::L2_RQSTS_MISS;
    _metricPerSecToId[SMUCSensorBase::L3_HITS_PER_SECOND] = SMUCSensorBase::MEM_LOAD_RETIRED_L3_HIT;
    _metricPerSecToId[SMUCSensorBase::L3_MISSES_PER_SECOND] = SMUCSensorBase::MEM_LOAD_RETIRED_L3_MISS;
    _metricPerSecToId[SMUCSensorBase::MISSBRANCHES_PER_SECOND] = SMUCSensorBase::PERF_COUNT_HW_BRANCH_MISSES;
56 57
    _metricPerSecToId[SMUCSensorBase::NETWORK_BYTES_XMIT_PER_SECOND] = SMUCSensorBase::NETWORK_XMIT_BYTES;
    _metricPerSecToId[SMUCSensorBase::NETWORK_BYTES_RCVD_PER_SECOND] = SMUCSensorBase::NETWORK_RCVD_BYTES;
58 59 60 61 62 63
    _metricPerSecToId[SMUCSensorBase::IOOPENS_PER_SECOND] = SMUCSensorBase::IOOPENS;
    _metricPerSecToId[SMUCSensorBase::IOCLOSES_PER_SECOND] = SMUCSensorBase::IOCLOSES;
    _metricPerSecToId[SMUCSensorBase::IOBYTESREAD_PER_SECOND] = SMUCSensorBase::IOBYTESREAD;
    _metricPerSecToId[SMUCSensorBase::IOBYTESWRITE_PER_SECOND] = SMUCSensorBase::IOBYTESWRITE;
    _metricPerSecToId[SMUCSensorBase::IOREADS_PER_SECOND] = SMUCSensorBase::IOREADS;
    _metricPerSecToId[SMUCSensorBase::IOWRITES_PER_SECOND] = SMUCSensorBase::IOWRITES;
64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84

	_metricRatioToPair.emplace(std::piecewise_construct, std::forward_as_tuple(SMUCSensorBase::L3_TO_INSTRUCTIONS_RATIO),
			std::forward_as_tuple(SMUCSensorBase::MEM_LOAD_UOPS_RETIRED_L3_MISS, SMUCSensorBase::INSTRUCTIONS));
	_metricRatioToPair.emplace(std::piecewise_construct, std::forward_as_tuple(SMUCSensorBase::CPI),
				std::forward_as_tuple(SMUCSensorBase::CLOCKS, SMUCSensorBase::INSTRUCTIONS));
	_metricRatioToPair.emplace(std::piecewise_construct, std::forward_as_tuple(SMUCSensorBase::LOADS_TO_STORES),
			std::forward_as_tuple(SMUCSensorBase::MEM_INST_RETIRED_ALL_LOADS, SMUCSensorBase::MEM_INST_RETIRED_ALL_STORES));
	_metricRatioToPair.emplace(std::piecewise_construct, std::forward_as_tuple(SMUCSensorBase::BRANCH_PER_INSTRUCTIONS),
			std::forward_as_tuple(SMUCSensorBase::PERF_COUNT_HW_BRANCH_MISSES, SMUCSensorBase::INSTRUCTIONS));
	_metricRatioToPair.emplace(std::piecewise_construct, std::forward_as_tuple(SMUCSensorBase::MISSBRANCHES_TO_TOTAL_BRANCH_RATIO),
			std::forward_as_tuple(SMUCSensorBase::PERF_COUNT_HW_BRANCH_MISSES,SMUCSensorBase::PERF_COUNT_HW_BRANCH_INSTRUCTIONS));
	_metricRatioToPair.emplace(std::piecewise_construct, std::forward_as_tuple(SMUCSensorBase::LOADS_TOL3MISS_RATIO),
			std::forward_as_tuple(SMUCSensorBase::MEM_INST_RETIRED_ALL_LOADS, SMUCSensorBase::MEM_LOAD_UOPS_RETIRED_L3_MISS));
	_metricRatioToPair.emplace(std::piecewise_construct, std::forward_as_tuple(SMUCSensorBase::IO_BYTES_READ_PER_OP),
			std::forward_as_tuple(SMUCSensorBase::IOBYTESREAD, SMUCSensorBase::IOREADS));
	_metricRatioToPair.emplace(std::piecewise_construct, std::forward_as_tuple(SMUCSensorBase::IO_BYTES_WRITE_PER_OP),
				std::forward_as_tuple(SMUCSensorBase::IOBYTESWRITE, SMUCSensorBase::IOWRITES));
	_metricRatioToPair.emplace(std::piecewise_construct, std::forward_as_tuple(SMUCSensorBase::NETWORK_XMIT_BYTES_PER_PKT),
					std::forward_as_tuple(SMUCSensorBase::NETWORK_XMIT_BYTES, SMUCSensorBase::NETWORK_XMIT_PKTS));
	_metricRatioToPair.emplace(std::piecewise_construct, std::forward_as_tuple(SMUCSensorBase::NETWORK_RCV_BYTES_PER_PKT),
					std::forward_as_tuple(SMUCSensorBase::NETWORK_RCVD_BYTES, SMUCSensorBase::NETWORK_RCVD_PKTS));
85 86
}

87
SMUCNGPerfOperator::~SMUCNGPerfOperator() {
88 89
}

90
SMUCNGPerfOperator::SMUCNGPerfOperator(const SMUCNGPerfOperator& other) : OperatorTemplate(other){
91
    copy(other);
92 93 94
}

SMUCNGPerfOperator& SMUCNGPerfOperator::operator=(const SMUCNGPerfOperator& other){
Carla Guillen's avatar
Carla Guillen committed
95
    OperatorTemplate::operator =(other);
96 97 98 99 100
    copy(other);
    return *this;
}

void SMUCNGPerfOperator::copy(const SMUCNGPerfOperator& other){
Carla Guillen's avatar
Carla Guillen committed
101 102
    this->_buffers = other._buffers;
    this->_metricToPosition = other._metricToPosition;
Carla Guillen's avatar
Carla Guillen committed
103 104
    this->_measuring_interval_s = other._measuring_interval_s;
    this->_go_back_ns = other._go_back_ns;
105
    this->_metricPerSecToId = other._metricPerSecToId;
106 107
}

108
void SMUCNGPerfOperator::printConfig(LOG_LEVEL ll) {
109
    OperatorTemplate<SMUCSensorBase>::printConfig(ll);
110
    LOG_VAR(ll) << "Operator " << _name << ":";
111
    LOG_VAR(ll) << "Metric to position map size(" << _metricToPosition.size() << "):";
112
    for(auto &kv : _metricToPosition){
113
    	LOG_VAR(ll) << "\tMetric = " << kv.first << " Position = " << kv.second;
114
    }
Carla Guillen's avatar
Carla Guillen committed
115 116
    LOG_VAR(ll) << "_measuring_interval_s = " << _measuring_interval_s;
    LOG_VAR(ll) << "_go_back_ns = " << _go_back_ns;
117 118
}

119
void SMUCNGPerfOperator::compute(U_Ptr unit) {
120
	auto inputs = unit->getInputs();
Carla Guillen's avatar
Carla Guillen committed
121
	auto timestamp = getTimestamp() - _go_back_ns;
122
	for(auto& outSensor : unit->getOutputs()){
123 124 125 126
		if(outSensor->getMetadata() == nullptr){
			LOG(error) << "No metadata defined, sensor " << outSensor->getName() <<  " can't compute anything.";
			continue;
		}
127
		if (outSensor->getMetric() == SMUCSensorBase::FREQUENCY) {
128 129 130 131 132
			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);
Carla Guillen Carias's avatar
Carla Guillen Carias committed
133 134 135 136
		} else if (outSensor->getMetric() == SMUCSensorBase::L3HIT_TO_L3MISS_RATIO ){
			computeL3HIT_TO_L3MISS_RATIO(inputs, outSensor, timestamp);
		} else if (outSensor->getMetric() == SMUCSensorBase::MEMORY_BANDWIDTH) {
			computeMEMORY_BANDWIDTH(inputs, outSensor, timestamp);
Carla Guillen's avatar
Carla Guillen committed
137
		} else if (isAMetricPerSecond(outSensor->getMetric())){
138 139 140 141 142
			computeMetricPerSecond(inputs, outSensor, timestamp);
		} else if (isAMetricRatio(outSensor->getMetric())){
			computeMetricRatio(inputs, outSensor, timestamp);
		} else {
			LOG(error) << "Derived metric " << outSensor->getMetric() << " not implemented.";
143
		}
Carla Guillen Carias's avatar
Carla Guillen Carias committed
144 145 146 147
		resetBuffers();
	}
}

Carla Guillen's avatar
Carla Guillen committed
148
void SMUCNGPerfOperator::query(const std::string & sensor_name, const uint64_t timestamp, vector<reading_t> &buffer){
Carla Guillen's avatar
Bug fix  
Carla Guillen committed
149
	if(!_queryEngine.querySensor(sensor_name, timestamp, timestamp, buffer, false)) {
150
		//LOG(debug) << "SMUCNGPerf Operator " << _name << " cannot read from sensor " << sensor_name  << "!";
Carla Guillen's avatar
Carla Guillen committed
151
	}
152 153
}

Carla Guillen Carias's avatar
Carla Guillen Carias committed
154 155 156
void SMUCNGPerfOperator::resetBuffers(){
	for(auto &buffer: _buffers){
		buffer.clear();
157 158
	}
}
159

160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185
void SMUCNGPerfOperator::computeMetricPerSecond(std::vector<SMUCNGPtr> &inputs, SMUCNGPtr& outSensor, const uint64_t timestamp) {
	auto found = _metricPerSecToId.find(outSensor->getMetric());
	if(found == _metricPerSecToId.end()) { //not found
		LOG(error) << "Metric per second " << outSensor->getMetric() << " not implemented.";
		return;
	}
	SMUCSensorBase::Metric_t metric = found->second;
	query(inputs[_metricToPosition[metric]]->getName(), timestamp, _buffers[0]);
	reading_t metricpersec;
	if(_buffers[0].size() > 0 && calculateMetricPerSec(_buffers[0][0], _measuring_interval_s, metricpersec, outSensor->getMetadata()->scale)){
		outSensor->storeReading(metricpersec);
	}
}

void SMUCNGPerfOperator::computeMetricRatio(std::vector<SMUCNGPtr>& inputs, SMUCNGPtr &outSensor, const uint64_t timestamp){
	std::vector<reading_t> & dividend = _buffers[0];
	std::vector<reading_t> & divisor = _buffers[1];
	auto found = _metricRatioToPair.find(outSensor->getMetric());
	if(found == _metricRatioToPair.end()) { //not found
		LOG(error) << "Metric ratio " << outSensor->getMetric() << " not implemented.";
		return;
	}
	SMUCSensorBase::Metric_t metric_dividend = found->second.first;
	SMUCSensorBase::Metric_t metric_divisor = found->second.second;
	query(inputs[_metricToPosition[metric_dividend]]->getName(), timestamp, dividend);
	query(inputs[_metricToPosition[metric_divisor]]->getName(), timestamp, divisor);
186 187
	bool wascalced = false;
	reading_t cpi;
188
	if (dividend.size() > 0 && divisor.size() > 0 && calculateMetricRatio(dividend[0], divisor[0], cpi, outSensor->getMetadata()->scale)) {
189 190 191 192 193 194 195 196 197 198
		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;
199
	if( clocks.size() > 0 && clocks_ref.size() > 0 && calculateFrequency(clocks_ref[0],clocks[0], MIN_FREQ_MHZ, MAX_FREQ_MHZ, frequency, outSensor->getMetadata()->scale)) {
200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237
		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) {
238
		if (calculateFlopsPerSec(scalar_double, scalar_single, packed128_double,
239
				packed128_single, packed256_double, packed256_single,
240
				packed512_double, packed512_single, result, outSensor->getMetadata()->scale, _measuring_interval_s) ) {
241 242 243
			outSensor->storeReading(result);
		}
	} else if(flop_metric == SMUCSensorBase::PACKED_FLOPS){
244 245 246
		if (calculatePackedFlopsPerSec(packed128_double, packed128_single,
				packed256_double, packed256_single, packed512_double,
				packed512_single, result, outSensor->getMetadata()->scale, _measuring_interval_s)) {
247 248 249 250 251
			outSensor->storeReading(result);
		}
	} else if(flop_metric == SMUCSensorBase::VECTORIZED_RATIO) {
		if(calculateVectorizationRatio(scalar_double, scalar_single, packed128_double,
				packed128_single, packed256_double, packed256_single,
252
				packed512_double, packed512_single, result, outSensor->getMetadata()->scale)) {
253 254 255 256 257
			outSensor->storeReading(result);
		}
	} else if (flop_metric == SMUCSensorBase::AVX512_TOVECTORIZED_RATIO) {
		if (calculateAVX512FlopsToVectorizedRatio(packed128_double,
				packed128_single, packed256_double, packed256_single,
258
				packed512_double, packed512_single, result, outSensor->getMetadata()->scale )) {
259 260 261 262 263
			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,
264
				packed512_double, packed512_single, result, outSensor->getMetadata()->scale)){
265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281
			outSensor->storeReading(result);
		}
	}
}



/*void SMUCNGPerfOperator::computeINSTR_INTRA_NODE_LOADIMBALANCE(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) {
Carla Guillen Carias's avatar
Carla Guillen Carias committed
282 283 284 285 286 287 288 289
	//MEM_LOAD_UOPS_RETIRED_L3_MISS/(MEM_LOAD_RETIRED_L3_HIT+MEM_LOAD_RETIRED_L3_MISS
	std::vector<reading_t> & l3_misses = _buffers[0];
	std::vector<reading_t> & l3_hits = _buffers[1];
	std::vector<reading_t> & l3_load_miss = _buffers[2];
	query(inputs[_metricToPosition[SMUCSensorBase::MEM_LOAD_UOPS_RETIRED_L3_MISS]]->getName(), timestamp, l3_misses);
	query(inputs[_metricToPosition[SMUCSensorBase::MEM_LOAD_RETIRED_L3_HIT]]->getName(), timestamp, l3_hits);
	query(inputs[_metricToPosition[SMUCSensorBase::MEM_LOAD_RETIRED_L3_MISS]]->getName(), timestamp, l3_load_miss);
	reading_t l3hitToMissRatio;
290
	if (l3_misses.size() > 0 && l3_hits.size() > 0 && l3_load_miss.size() > 0 && calculateL3HitToL3MissRatio(l3_misses[0], l3_hits[0], l3_load_miss[0], l3hitToMissRatio, outSensor->getMetadata()->scale)) {
Carla Guillen Carias's avatar
Carla Guillen Carias committed
291 292
		outSensor->storeReading(l3hitToMissRatio);
	}
293 294
}

295 296 297 298
void SMUCNGPerfOperator::computeMEMORY_BANDWIDTH(std::vector<SMUCNGPtr>& inputs, SMUCNGPtr& outSensor, const uint64_t timestamp) {
	std::vector<reading_t> & mem_counters = _buffers[0];

	reading_t memory_bw;
299 300 301 302 303 304 305 306 307 308 309 310
	query(inputs[_metricToPosition[SMUCSensorBase::CAS_COUNT_READ0]]->getName(), timestamp, mem_counters);	
	query(inputs[_metricToPosition[SMUCSensorBase::CAS_COUNT_READ1]]->getName(), timestamp, mem_counters);	
	query(inputs[_metricToPosition[SMUCSensorBase::CAS_COUNT_READ2]]->getName(), timestamp, mem_counters);	
	query(inputs[_metricToPosition[SMUCSensorBase::CAS_COUNT_READ3]]->getName(), timestamp, mem_counters);	
	query(inputs[_metricToPosition[SMUCSensorBase::CAS_COUNT_READ4]]->getName(), timestamp, mem_counters);	
	query(inputs[_metricToPosition[SMUCSensorBase::CAS_COUNT_READ5]]->getName(), timestamp, mem_counters);	
	query(inputs[_metricToPosition[SMUCSensorBase::CAS_COUNT_WRITE0]]->getName(), timestamp, mem_counters);	
	query(inputs[_metricToPosition[SMUCSensorBase::CAS_COUNT_WRITE1]]->getName(), timestamp, mem_counters);	
	query(inputs[_metricToPosition[SMUCSensorBase::CAS_COUNT_WRITE2]]->getName(), timestamp, mem_counters);	
	query(inputs[_metricToPosition[SMUCSensorBase::CAS_COUNT_WRITE3]]->getName(), timestamp, mem_counters);	
	query(inputs[_metricToPosition[SMUCSensorBase::CAS_COUNT_WRITE4]]->getName(), timestamp, mem_counters);	
	query(inputs[_metricToPosition[SMUCSensorBase::CAS_COUNT_WRITE5]]->getName(), timestamp, mem_counters);	
311
	if(mem_counters.size() > 0 && calculateMemoryBandwidth(mem_counters, memory_bw, _measuring_interval_s, outSensor->getMetadata()->scale)){
312 313 314
		outSensor->storeReading(memory_bw);
	}
	
315
}
Carla Guillen's avatar
Carla Guillen committed
316 317

bool SMUCNGPerfOperator::isAMetricPerSecond(SMUCSensorBase::Metric_t comp){
318 319 320 321 322 323 324 325
	if(_metricPerSecToId.find(comp) != _metricPerSecToId.end() ){ //found
		return true;
	}
	return false;
}

bool SMUCNGPerfOperator::isAMetricRatio(SMUCSensorBase::Metric_t comp){
	if(_metricRatioToPair.find(comp) != _metricRatioToPair.end()){
Carla Guillen's avatar
Carla Guillen committed
326 327 328 329
		return true;
	}
	return false;
}