cppJoules.cpp

// ============================================================
//  cppJoules.cpp  --  Windows / Intel Power Gadget 3.6 only
//  Merged: RAPLDevice + EnergyTracker implementations
// ============================================================

#include "cppJoules.h"
#include <iostream>
#include <fstream>
#include <memory>
#include <string>

// ============================================================
//  Helper: load a function from the already-opened handler
// ============================================================
namespace {
	template<typename FnPtr>
	FnPtr getFunc(HINSTANCE lib, const char* name)
	{
		return reinterpret_cast<FnPtr>(GetProcAddress(lib, name));
	}
} // anonymous namespace

// ============================================================
//  RAPLDevice
// ============================================================

RAPLDevice::RAPLDevice()
{
	// Locate EnergyLib64.dll in System32
	char sysDir[MAX_PATH] = {};
	GetSystemDirectoryA(sysDir, MAX_PATH);
	std::string dllPath = std::string(sysDir) + "\\EnergyLib64.dll";

	handler = LoadLibraryA(dllPath.c_str());
	if (!handler)
	{
		std::cerr << "[cppJoules] Could not load EnergyLib64.dll from "
			<< dllPath << "\n"
			<< "            Make sure Intel Power Gadget 3.6 is installed.\n";
		return;
	}

	// ── Initialize the library ──────────────────────────────
	auto _Init = getFunc<fn_void>(handler, "IntelEnergyLibInitialize");
	auto _GetNumMsrs = getFunc<fn_intp>(handler, "GetNumMsrs");
	auto _GetNumNodes = getFunc<fn_intp>(handler, "GetNumNodes");
	auto _GetMsrFunc = getFunc<fn_int_intp>(handler, "GetMsrFunc");
	auto _GetMsrName = getFunc<fn_int_wcp>(handler, "GetMsrName");

	if (!_Init || !_GetNumMsrs || !_GetNumNodes || !_GetMsrFunc || !_GetMsrName)
	{
		std::cerr << "[cppJoules] Failed to resolve required functions from EnergyLib64.dll.\n";
		FreeLibrary(handler);
		handler = nullptr;
		return;
	}

	_Init();

	int numMsrs = 0;  _GetNumMsrs(&numMsrs);
	int numNodes = 0;  _GetNumNodes(&numNodes);

	// ── Discover power domains ──────────────────────────────
	// We only care about MSR_FUNC_POWER entries.
	wchar_t nameBuf[128] = {};
	for (int node = 0; node < numNodes; ++node)
	{
		for (int msr = 0; msr < numMsrs; ++msr)
		{
			int func = 0;
			_GetMsrFunc(msr, &func);

			if (func == MSR_FUNC_POWER)
			{
				_GetMsrName(msr, nameBuf);
				//std::wstring ws(nameBuf);
				//std::string  key(ws.begin(), ws.end());
				//key += "-" + std::to_string(node);   // e.g. "Processor-0", "IA-0"
				//devices[key] = { node, msr };
				std::wstring ws(nameBuf);

				// Proper wide-to-narrow conversion using the Windows API.
				// Power Gadget names are pure ASCII so this is always safe,
				// but WideCharToMultiByte is the correct MSVC way to do it.
				int len = WideCharToMultiByte(
					CP_ACP,          // code page: system default (ANSI)
					0,               // no flags
					ws.c_str(),      // source wide string
					-1,              // -1 means "read until null terminator"
					nullptr,         // no output yet — just measuring length
					0,
					nullptr, nullptr);

				std::string key(len - 1, '\0');   // len includes the null, subtract it
				WideCharToMultiByte(
					CP_ACP, 0,
					ws.c_str(), -1,
					&key[0], len,    // write into the string's buffer
					nullptr, nullptr);

				key += "-" + std::to_string(node);
				devices[key] = { node, msr };
			}
		}
	}
}

RAPLDevice::~RAPLDevice()
{
	if (handler) FreeLibrary(handler);
}

std::map<std::string, unsigned long long> RAPLDevice::getEnergy()
{
	std::map<std::string, unsigned long long> energies;

	if (!handler) return energies;   // DLL not loaded → return empty

	auto _ReadSample = getFunc<fn_bool>(handler, "ReadSample");
	auto _GetPowerData = getFunc<fn_iidp_ip>(handler, "GetPowerData");

	if (!_ReadSample || !_GetPowerData) return energies;

	// ReadSample() must be called before GetPowerData().
	// The very first call only "primes" the hardware counters,
	// so we return zeros and flip the initialized flag.
	_ReadSample();

	for (const auto& dev : devices)
	{
		double data[10] = {};
		int    nData = 0;

		if (initialized)
		{
			_GetPowerData(dev.second.first, dev.second.second, data, &nData);
			// data[1] = cumulative energy in mWh
			//energies[dev.first] = static_cast<unsigned long long>(data[1]);
			// 
			// Convert mWh → mJ  (1 mWh = 3600 mJ) for finer resolution
			energies[dev.first] = static_cast<unsigned long long>(data[1] * 3600.0);
		}
		else
		{
			energies[dev.first] = 0ULL;
		}
	}

	if (!initialized) initialized = true;

	return energies;
}

// ============================================================
//  EnergyTracker
// ============================================================

EnergyTracker::EnergyTracker()
{
	rapl_device = new RAPLDevice();
}

EnergyTracker::~EnergyTracker()
{
	delete rapl_device;
}

void EnergyTracker::start()
{
	if (state == STARTED)
	{
		std::cout << "[cppJoules] Tracker already started.\n";
		return;
	}

	auto ts = std::chrono::system_clock::now();
	auto reading = rapl_device->getEnergy();

	energy_readings.emplace_back(ts, reading);
	state = STARTED;
}

void EnergyTracker::stop()
{
	if (state == UNINITIALIZED)
	{
		std::cout << "[cppJoules] Tracker was never started.\n";
		return;
	}
	if (state == STOPPED)
	{
		std::cout << "[cppJoules] Tracker already stopped.\n";
		return;
	}

	auto ts = std::chrono::system_clock::now();
	auto reading = rapl_device->getEnergy();

	energy_readings.emplace_back(ts, reading);
	state = STOPPED;
}

void EnergyTracker::calculate_energy()
{
	if (state == UNINITIALIZED)
	{
		std::cout << "[cppJoules] Tracker was never started.\n";
		return;
	}
	if (state != STOPPED)
	{
		std::cout << "[cppJoules] Call stop() before calculate_energy().\n";
		return;
	}

	last_calculated_energies.clear();
	last_calculated_time = 0.f;

	// energy_readings is a flat list of alternating start/stop pairs
	for (size_t i = 0; i + 1 < energy_readings.size(); i += 2)
	{
		const auto& start = energy_readings[i];
		const auto& stop = energy_readings[i + 1];

		last_calculated_time +=
			std::chrono::duration<float>(stop.timestamp - start.timestamp).count();

		for (const auto& domain : start.energies)
		{
			const std::string& key = domain.first;
			// stop may not have the key if Power Gadget failed mid-run
			if (stop.energies.count(key) == 0) continue;

			long long delta =
				static_cast<long long>(stop.energies.at(key)) -
				static_cast<long long>(domain.second);

			// Intel Power Gadget counters don't wrap like Linux RAPL,
			// but guard against negative deltas from a first-sample prime.
			if (delta >= 0)
				last_calculated_energies[key] += delta;
		}
	}

	energy_readings.clear();  // reset for potential re-use
	state = UNINITIALIZED;
}

void EnergyTracker::print_energy() const
{
	if (last_calculated_energies.empty())
	{
		std::cout << "[cppJoules] No data — call calculate_energy() first.\n";
		return;
	}

	std::cout << "Duration (s): " << last_calculated_time << "\n";
	for (const auto& e : last_calculated_energies)
		std::cout << e.first << " : " << e.second << " mJ\n";
}

void EnergyTracker::save_csv(const std::string& file) const
{
	std::ofstream out(file);
	if (!out.is_open())
	{
		std::cerr << "[cppJoules] Could not open file: " << file << "\n";
		return;
	}

	// Header
	out << "Time(s),";   // domain columns already have their names
	// (no change needed in csv, but add a comment in the file header)

	for (const auto& e : last_calculated_energies)
		out << e.first << ",";
	out << "\n";

	// Values
	out << last_calculated_time << ",";
	for (const auto& e : last_calculated_energies)
		out << e.second << ",";
	out << "\n";
}