XNSim/XNMonitorServer/SystemInfoMonitor.cpp

#include "SystemInfoMonitor.h"
#include <nlohmann/json.hpp>

using json = nlohmann::json;

SystemInfoMonitor::~SystemInfoMonitor()
{
	//注销引擎状态订阅
	TopicManager::Instance()->unregisterSubscriber("XNSim::XNSimStatus::XNEngineStatus");
	//注销线程状态订阅
	TopicManager::Instance()->unregisterSubscriber("XNSim::XNSimStatus::XNThreadStatus");
}

std::string SystemInfoMonitor::Initialize()
{
	//注册引擎状态订阅
	XNDDSErrorCode ret =
		TopicManager::Instance()->registerSubscriber<XNSim::XNSimStatus::XNEngineStatusPubSubType>(
			"XNSim::XNSimStatus::XNEngineStatus",
			std::bind(&SystemInfoMonitor::EngineStatusListener, this, std::placeholders::_1));
	if (ret != XNDDSErrorCode::SUCCESS) {
		return "Failed to register engine status subscriber, error code: "
			   + std::to_string(static_cast<int>(ret));
	}
	//注册线程状态订阅
	ret =
		TopicManager::Instance()->registerSubscriber<XNSim::XNSimStatus::XNThreadStatusPubSubType>(
			"XNSim::XNSimStatus::XNThreadStatus",
			std::bind(&SystemInfoMonitor::ThreadStatusListener, this, std::placeholders::_1));
	if (ret != XNDDSErrorCode::SUCCESS) {
		return "Failed to register thread status subscriber, error code: "
			   + std::to_string(static_cast<int>(ret));
	}
	m_ThreadCycleCount.clear();
	m_EngineStatusUpdate = false;
	return "Success";
}

std::string SystemInfoMonitor::GetSystemInfo()
{
	std::lock_guard<std::mutex> locker(m_EngineStatusMutex);
	json jsonObj;

	// 创建引擎状态JSON对象
	json engineStatusObj;
	engineStatusObj["engineName"]	= m_EngineStatus.XNEngineName();
	engineStatusObj["engineID"]		= m_EngineStatus.XNEngineID();
	engineStatusObj["engineStatus"] = m_EngineStatus.XNEngineSt();
	std::string affinity;
	for (int i = 0; i < sizeof(m_EngineStatus.XNEngineAff()); i++) {
		if ((m_EngineStatus.XNEngineAff() >> i) & 1 == 1) {
			affinity += std::to_string(i) + ",";
		}
	}
	if (!affinity.empty()) {
		affinity.pop_back(); // 移除最后一个逗号
	}
	engineStatusObj["engineAffinity"] = affinity;
	engineStatusObj["threadCount"]	  = m_EngineStatus.XNThCnt();

	// 创建核心状态JSON对象
	json coreStatusObj;
	const auto &coreStatus	   = m_EngineStatus.XNCoreSt();
	coreStatusObj["fwStatus"]  = coreStatus.XNFWStatus();
	coreStatusObj["tmStatus"]  = coreStatus.XNTMStatus();
	coreStatusObj["emStatus"]  = coreStatus.XNEMStatus();
	coreStatusObj["sdStatus"]  = coreStatus.XNSDStatus();
	coreStatusObj["thmStatus"] = coreStatus.XNThMStatus();
	coreStatusObj["mmStatus"]  = coreStatus.XNMMStatus();
	coreStatusObj["smStatus"]  = coreStatus.XNSMStatus();
	coreStatusObj["dmStatus"]  = coreStatus.XNDMStatus();

	// 将核心状态添加到引擎状态中
	engineStatusObj["coreStatus"] = coreStatusObj;

	// 将引擎状态添加到主JSON对象中
	jsonObj["engineStatus"] = engineStatusObj;

	m_EngineStatusUpdate = false;
	return jsonObj.dump();
}

std::string SystemInfoMonitor::GetAllThreadInfo()
{
	std::lock_guard<std::mutex> locker(m_ThreadStatusMutex);
	json jsonObj;

	// 创建线程状态JSON对象
	json threadStatusObj;
	for (const auto &status : m_ThreadStatus) {
		json threadObj;
		threadObj["threadName"] = status.second.XNThreadName();
		std::string affinity;
		for (int i = 0; i < sizeof(status.second.XNThreadAff()); i++) {
			if ((status.second.XNThreadAff() >> i) & 1 == 1) {
				affinity += std::to_string(i) + ",";
			}
		}
		if (!affinity.empty()) {
			affinity.pop_back(); // 移除最后一个逗号
		}
		threadObj["threadAffinity"] = affinity;
		threadObj["threadPro"]		= status.second.XNThreadPro();
		uint64_t cycleCount			= status.second.XNThRunCnt();
		if (m_ThreadCycleCount.find(status.first) != m_ThreadCycleCount.end()) {
			if (cycleCount <= m_ThreadCycleCount[status.first]) {
				threadObj["threadStatus"] = 99;
				continue;
			}
		}
		threadObj["threadRunCount"]					  = cycleCount;
		m_ThreadCycleCount[status.first]			  = cycleCount;
		threadObj["threadStatus"]					  = status.second.XNThreadSt();
		threadObj["threadCurrentFrequency"]			  = status.second.XNThCurFreq();
		threadObj["threadSetFrequency"]				  = status.second.XNThSetFreq();
		threadStatusObj[std::to_string(status.first)] = threadObj;
	}
	jsonObj["threadStatus"] = threadStatusObj;

	return jsonObj.dump();
}

void SystemInfoMonitor::EngineStatusListener(const XNSim::XNSimStatus::XNEngineStatus &status)
{
	std::lock_guard<std::mutex> locker(m_EngineStatusMutex);
	m_EngineStatusUpdate = true;
	m_EngineStatus		 = status;
}

void SystemInfoMonitor::ThreadStatusListener(const XNSim::XNSimStatus::XNThreadStatus &status)
{
	std::lock_guard<std::mutex> locker(m_ThreadStatusMutex);
	m_ThreadStatus[status.XNThreadID()] = status;
}