gecko-dev/tools/profiler/IntelPowerGadget.cpp

311 lines
8.5 KiB
C++

/*
* Copyright 2013, Intel Corporation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* Author: Joe Olivas <joseph.k.olivas@intel.com>
*/
#include "nsDebug.h"
#include "nsString.h"
#include "IntelPowerGadget.h"
#include "prenv.h"
IntelPowerGadget::IntelPowerGadget() :
libpowergadget(nullptr),
Initialize(nullptr),
GetNumNodes(nullptr),
GetMsrName(nullptr),
GetMsrFunc(nullptr),
ReadMSR(nullptr),
WriteMSR(nullptr),
GetIAFrequency(nullptr),
GetTDP(nullptr),
GetMaxTemperature(nullptr),
GetThresholds(nullptr),
GetTemperature(nullptr),
ReadSample(nullptr),
GetSysTime(nullptr),
GetRDTSC(nullptr),
GetTimeInterval(nullptr),
GetBaseFrequency(nullptr),
GetPowerData(nullptr),
StartLog(nullptr),
StopLog(nullptr),
GetNumMsrs(nullptr),
packageMSR(-1),
cpuMSR(-1),
freqMSR(-1),
tempMSR(-1)
{
}
bool
IntelPowerGadget::Init()
{
bool success = false;
const char *path = PR_GetEnv("IPG_Dir");
nsCString ipg_library;
if (path && *path) {
ipg_library.Append(path);
ipg_library.Append('/');
ipg_library.AppendLiteral(PG_LIBRARY_NAME);
libpowergadget = PR_LoadLibrary(ipg_library.get());
}
if(libpowergadget) {
Initialize = (IPGInitialize) PR_FindFunctionSymbol(libpowergadget, "IntelEnergyLibInitialize");
GetNumNodes = (IPGGetNumNodes) PR_FindFunctionSymbol(libpowergadget, "GetNumNodes");
GetMsrName = (IPGGetMsrName) PR_FindFunctionSymbol(libpowergadget, "GetMsrName");
GetMsrFunc = (IPGGetMsrFunc) PR_FindFunctionSymbol(libpowergadget, "GetMsrFunc");
ReadMSR = (IPGReadMSR) PR_FindFunctionSymbol(libpowergadget, "ReadMSR");
WriteMSR = (IPGWriteMSR) PR_FindFunctionSymbol(libpowergadget, "WriteMSR");
GetIAFrequency = (IPGGetIAFrequency) PR_FindFunctionSymbol(libpowergadget, "GetIAFrequency");
GetTDP = (IPGGetTDP) PR_FindFunctionSymbol(libpowergadget, "GetTDP");
GetMaxTemperature = (IPGGetMaxTemperature) PR_FindFunctionSymbol(libpowergadget, "GetMaxTemperature");
GetThresholds = (IPGGetThresholds) PR_FindFunctionSymbol(libpowergadget, "GetThresholds");
GetTemperature = (IPGGetTemperature) PR_FindFunctionSymbol(libpowergadget, "GetTemperature");
ReadSample = (IPGReadSample) PR_FindFunctionSymbol(libpowergadget, "ReadSample");
GetSysTime = (IPGGetSysTime) PR_FindFunctionSymbol(libpowergadget, "GetSysTime");
GetRDTSC = (IPGGetRDTSC) PR_FindFunctionSymbol(libpowergadget, "GetRDTSC");
GetTimeInterval = (IPGGetTimeInterval) PR_FindFunctionSymbol(libpowergadget, "GetTimeInterval");
GetBaseFrequency = (IPGGetBaseFrequency) PR_FindFunctionSymbol(libpowergadget, "GetBaseFrequency");
GetPowerData = (IPGGetPowerData) PR_FindFunctionSymbol(libpowergadget, "GetPowerData");
StartLog = (IPGStartLog) PR_FindFunctionSymbol(libpowergadget, "StartLog");
StopLog = (IPGStopLog) PR_FindFunctionSymbol(libpowergadget, "StopLog");
GetNumMsrs = (IPGGetNumMsrs) PR_FindFunctionSymbol(libpowergadget, "GetNumMsrs");
}
if(Initialize) {
Initialize();
int msrCount = GetNumberMsrs();
wchar_t name[1024] = {0};
for(int i = 0; i < msrCount; ++i) {
GetMsrName(i, name);
int func = 0;
GetMsrFunc(i, &func);
// MSR for frequency
if(wcscmp(name, L"CPU Frequency") == 0 && (func == 0)) {
this->freqMSR = i;
}
// MSR for Package
else if(wcscmp(name, L"Processor") == 0 && (func == 1)) {
this->packageMSR = i;
}
// MSR for CPU
else if(wcscmp(name, L"IA") == 0 && (func == 1)) {
this->cpuMSR = i;
}
// MSR for Temperature
else if(wcscmp(name, L"Package") == 0 && (func == 2)) {
this->tempMSR = i;
}
}
// Grab one sample at startup for a diff
TakeSample();
success = true;
}
return success;
}
IntelPowerGadget::~IntelPowerGadget()
{
if(libpowergadget) {
NS_WARNING("Unloading PowerGadget library!\n");
PR_UnloadLibrary(libpowergadget);
libpowergadget = nullptr;
Initialize = nullptr;
GetNumNodes = nullptr;
GetMsrName = nullptr;
GetMsrFunc = nullptr;
ReadMSR = nullptr;
WriteMSR = nullptr;
GetIAFrequency = nullptr;
GetTDP = nullptr;
GetMaxTemperature = nullptr;
GetThresholds = nullptr;
GetTemperature = nullptr;
ReadSample = nullptr;
GetSysTime = nullptr;
GetRDTSC = nullptr;
GetTimeInterval = nullptr;
GetBaseFrequency = nullptr;
GetPowerData = nullptr;
StartLog = nullptr;
StopLog = nullptr;
GetNumMsrs = nullptr;
}
}
int
IntelPowerGadget::GetNumberNodes()
{
int nodes = 0;
if(GetNumNodes) {
int ok = GetNumNodes(&nodes);
}
return nodes;
}
int
IntelPowerGadget::GetNumberMsrs()
{
int msrs = 0;
if(GetNumMsrs) {
int ok = GetNumMsrs(&msrs);
}
return msrs;
}
int
IntelPowerGadget::GetCPUFrequency(int node)
{
int frequency = 0;
if(GetIAFrequency) {
int ok = GetIAFrequency(node, &frequency);
}
return frequency;
}
double
IntelPowerGadget::GetTdp(int node)
{
double tdp = 0.0;
if(GetTDP) {
int ok = GetTDP(node, &tdp);
}
return tdp;
}
int
IntelPowerGadget::GetMaxTemp(int node)
{
int maxTemperatureC = 0;
if(GetMaxTemperature) {
int ok = GetMaxTemperature(node, &maxTemperatureC);
}
return maxTemperatureC;
}
int
IntelPowerGadget::GetTemp(int node)
{
int temperatureC = 0;
if(GetTemperature) {
int ok = GetTemperature(node, &temperatureC);
}
return temperatureC;
}
int
IntelPowerGadget::TakeSample()
{
int ok = 0;
if(ReadSample) {
ok = ReadSample();
}
return ok;
}
uint64_t
IntelPowerGadget::GetRdtsc()
{
uint64_t rdtsc = 0;
if(GetRDTSC) {
int ok = GetRDTSC(&rdtsc);
}
return rdtsc;
}
double
IntelPowerGadget::GetInterval()
{
double interval = 0.0;
if(GetTimeInterval) {
int ok = GetTimeInterval(&interval);
}
return interval;
}
double
IntelPowerGadget::GetCPUBaseFrequency(int node)
{
double freq = 0.0;
if(GetBaseFrequency) {
int ok = GetBaseFrequency(node, &freq);
}
return freq;
}
double
IntelPowerGadget::GetTotalPackagePowerInWatts()
{
int nodes = GetNumberNodes();
double totalPower = 0.0;
for(int i = 0; i < nodes; ++i) {
totalPower += GetPackagePowerInWatts(i);
}
return totalPower;
}
double
IntelPowerGadget::GetPackagePowerInWatts(int node)
{
int numResult = 0;
double result[] = {0.0, 0.0, 0.0};
if(GetPowerData && packageMSR != -1) {
int ok = GetPowerData(node, packageMSR, result, &numResult);
}
return result[0];
}
double
IntelPowerGadget::GetTotalCPUPowerInWatts()
{
int nodes = GetNumberNodes();
double totalPower = 0.0;
for(int i = 0; i < nodes; ++i) {
totalPower += GetCPUPowerInWatts(i);
}
return totalPower;
}
double
IntelPowerGadget::GetCPUPowerInWatts(int node)
{
int numResult = 0;
double result[] = {0.0, 0.0, 0.0};
if(GetPowerData && cpuMSR != -1) {
int ok = GetPowerData(node, cpuMSR, result, &numResult);
}
return result[0];
}
double
IntelPowerGadget::GetTotalGPUPowerInWatts()
{
int nodes = GetNumberNodes();
double totalPower = 0.0;
for(int i = 0; i < nodes; ++i) {
totalPower += GetGPUPowerInWatts(i);
}
return totalPower;
}
double
IntelPowerGadget::GetGPUPowerInWatts(int node)
{
return 0.0;
}