The Tor Browser / file revision

 /*

  * 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.AppendLiteral("/");

         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;

 }