#ifndef ANALYSIS_PROCESS_MANAGER_H
#define ANALYSIS_PROCESS_MANAGER_H
#include "LayerReader.h"
#include "../comon/CheckSystem.h"
#include "../comon/ThreadPool.h"
#include "../comon/Logger.h"
#include <vector>
#include <string>
#include <windows.h>
#include <set>
typedef std::pair<std::string, std::string> ObjectHandlePair;
enum ProcessExecutionStatus {
PROCESS_NOT_STARTED,
PROCESS_RUNNING,
PROCESS_COMPLETED,
PROCESS_FAILED,
PROCESS_TIMEOUT
};
struct WorkerProcessInfo {
int processId;
PROCESS_INFORMATION procInfo;
std::string taskFile;
std::string resultFile;
ProcessExecutionStatus status;
DWORD startTime;
DWORD endTime;
int tasksAssigned;
int resultsReturned;
};
struct ProcessManagerConfig {
int totalObjects; // 总对象数量
int totalTasks; // 总任务数（对象对数）
int processCount; // 进程数量
int threadsPerProcess; // 每个进程的线程数
std::string workerExecutable; // 工作进程可执行文件路径
std::string tempFileDirectory; // 临时文件目录
DWORD processTimeoutMs; // 进程超时时间
bool cleanupTempFiles; // 是否清理临时文件
};
struct ProcessManagerResult {
ProcessExecutionStatus overallStatus;
std::vector<InterferenceResult> interferenceResults;
int totalProcessesCreated;
int successfulProcesses;
int failedProcesses;
int timeoutProcesses;
int totalTasksAssigned;
int totalResultsCollected;
DWORD totalExecutionTimeMs;
std::string errorMessage;
};
// 主进程管理类
class AnalysisProcessManager {
public:
AnalysisProcessManager
();
~AnalysisProcessManager
();
// 执行多进程干涉检查 - 修改为使用对象句柄
bool performMultiProcessInterferenceCheck
(
const std::vector<std::string>& objectHandles, // 改为对象句柄
std::vector<InterferenceResult>& resultList,
int processCount = 0,
int threadsPerProcess = 0
);
// 获取执行结果
const ProcessManagerResult& getResult
() const { return m_result; }
// 获取进程状态
ProcessExecutionStatus getProcessStatus
(int processId
) const;
// 获取所有进程状态
std::vector<WorkerProcessInfo> getAllProcessStatus
() const;
// 终止所有工作进程
void terminateAllProcesses
();
// 生成进程管理报告
std::string generateProcessReport
() const;
// 静态方法：计算最优配置
static void calculateOptimalConfiguration
(int totalTasks, int& processCount, int& threadsPerProcess
);
private:
// 创建工作进程
bool createWorkerProcess
(int processId, const std::vector<ObjectHandlePair>& tasks, int threadsPerProcess
);
// 分割任务到进程 - 修改为使用对象句柄
void splitTasksToProcesses
(const std::vector<std::string>& objectHandles,
int processCount,
std::vector<std::vector<ObjectHandlePair>>& processTasks
);
// 写入任务文件 - 修改为写入对象句柄
bool writeTaskFile
(const std::string& taskFile, const std::vector<ObjectHandlePair>& tasks
);
// 读取结果文件
bool readResultFile
(const std::string& resultFile, std::vector<InterferenceResult>& resultList
);
// 等待进程完成
bool waitForProcessCompletion
(WorkerProcessInfo& processInfo
);
// 监控进程状态
void monitorProcesses
();
// 清理临时文件
void cleanupTempFiles
();
// 检查工作进程可执行文件
bool checkWorkerExecutable
();
// 记录进程事件
void logProcessEvent
(int processId, const std::string& event
);
// 字符串序列化辅助函数
static void writeString
(std::ofstream& file, const std::string& str
);
static std::string readString
(std::ifstream& file
);
private:
ProcessManagerConfig m_config;
ProcessManagerResult m_result;
std::vector<WorkerProcessInfo> m_workerProcesses;
Logger& m_logger;
DWORD m_startTime;
bool m_stopRequested;
// 字符串转换辅助函数
static std::string intToString
(int value
);
static std::string formatTimeMs
(DWORD milliseconds
);
};
#endif // ANALYSIS_PROCESS_MANAGER_H
#include "AnalysisProcessManager.h"
#include <sstream>
#include <fstream>
#include <iomanip>
#include <algorithm>
#include <set>
// 字符串转换辅助函数
std::string AnalysisProcessManager::intToString
(int value
) {
std::stringstream ss;
ss << value;
return ss.str
();
}
std::string AnalysisProcessManager::formatTimeMs
(DWORD milliseconds
) {
DWORD seconds = milliseconds / 1000;
DWORD minutes = seconds / 60;
DWORD hours = minutes / 60;
std::stringstream ss;
if
(hours > 0
) {
ss << hours << "h ";
}
if
(minutes > 0
) {
ss <<
(minutes % 60
) << "m ";
}
ss <<
(seconds % 60
) << "s ";
ss <<
(milliseconds % 1000
) << "ms";
return ss.str
();
}
// 字符串序列化辅助函数
void AnalysisProcessManager::writeString
(std::ofstream& file, const std::string& str
)
{
int length =
(int
)str.length
();
file.write
(reinterpret_cast<const char*>
(&length
), sizeof
(int
));
if
(length > 0
) {
file.write
(str.c_str
(), length
);
}
file.flush
();
}
std::string AnalysisProcessManager::readString
(std::ifstream& file
) {
int length = 0;
file.read
(reinterpret_cast<char*>
(&length
), sizeof
(int
));
if
(length < 0
) {
return "";
}
if
(length > 0
) {
std::string result;
result.resize
(length
);
file.read
(&result[0], length
);
return result;
}
return "";
}
AnalysisProcessManager::AnalysisProcessManager
()
: m_logger
(Logger::getInstance
()), m_startTime
(0
), m_stopRequested
(false
) {
// 初始化配置
m_config.workerExecutable = "Analysis.exe";
m_config.tempFileDirectory = "temp";
m_config.processTimeoutMs = 3600000;
m_config.cleanupTempFiles = true;
// 初始化结果
m_result.overallStatus = PROCESS_NOT_STARTED;
m_result.totalProcessesCreated = 0;
m_result.successfulProcesses = 0;
m_result.failedProcesses = 0;
m_result.timeoutProcesses = 0;
m_result.totalTasksAssigned = 0;
m_result.totalResultsCollected = 0;
m_result.totalExecutionTimeMs = 0;
}
AnalysisProcessManager::~AnalysisProcessManager
()
{
terminateAllProcesses
();
if
(m_config.cleanupTempFiles
) {
cleanupTempFiles
();
}
}
bool AnalysisProcessManager::performMultiProcessInterferenceCheck
(const std::vector<std::string>& objectHandles,std::vector<InterferenceResult>& resultList,int processCount,int threadsPerProcess
)
{
m_logger.info
("开始多进程干涉检查（使用对象句柄和距离检查）", "AnalysisProcessManager"
);
m_startTime = GetTickCount
();
m_result.overallStatus = PROCESS_RUNNING;
// 检查对象数量
if
(objectHandles.size
() < 2
) {
m_result.errorMessage = "对象数量不足，无法进行干涉检查";
m_logger.error
(m_result.errorMessage, "AnalysisProcessManager"
);
m_result.overallStatus = PROCESS_FAILED;
return false;
}
// 检查工作进程可执行文件
if
(!checkWorkerExecutable
()) {
m_result.errorMessage = "工作进程可执行文件不存在: " + m_config.workerExecutable;
m_logger.error
(m_result.errorMessage, "AnalysisProcessManager"
);
m_result.overallStatus = PROCESS_FAILED;
return false;
}
// 计算总任务数
m_config.totalObjects =
(int
)objectHandles.size
();
m_config.totalTasks = m_config.totalObjects *
(m_config.totalObjects - 1
) / 2;
// 计算最优配置
if
(processCount <= 0 || threadsPerProcess <= 0
) {
calculateOptimalConfiguration
(m_config.totalTasks, processCount, threadsPerProcess
);
}
m_config.processCount = processCount;
m_config.threadsPerProcess = threadsPerProcess;
m_logger.info
("多进程配置: " + intToString
(m_config.processCount
) + " 个进程, " +
intToString
(m_config.threadsPerProcess
) + " 线程/进程, " +
intToString
(m_config.totalTasks
) + " 个任务", "AnalysisProcessManager"
);
// 分割任务
std::vector<std::vector<ObjectHandlePair> > processTasks
(m_config.processCount
);
splitTasksToProcesses
(objectHandles, m_config.processCount, processTasks
);
// 创建工作进程
m_workerProcesses.resize
(m_config.processCount
);
bool success = true;
for
(int i = 0; i < m_config.processCount; ++i
) {
if
(!createWorkerProcess
(i, processTasks[i], m_config.threadsPerProcess
)) {
m_logger.error
("创建进程 " + intToString
(i
) + " 失败", "AnalysisProcessManager"
);
success = false;
break;
}
m_result.totalTasksAssigned +=
(int
)processTasks[i].size
();
}
if
(!success
) {
terminateAllProcesses
();
m_result.overallStatus = PROCESS_FAILED;
return false;
}
m_result.totalProcessesCreated = m_config.processCount;
// 监控进程状态
monitorProcesses
();
// 收集结果
for
(int i = 0; i < m_config.processCount; ++i
)
{
if
(m_workerProcesses[i].status == PROCESS_COMPLETED
)
{
std::vector<InterferenceResult> processResults;
if
(readResultFile
(m_workerProcesses[i].resultFile, processResults
))
{
resultList.insert
(resultList.end
(), processResults.begin
(), processResults.end
());
m_result.totalResultsCollected +=
(int
)processResults.size
();
m_workerProcesses[i].resultsReturned =
(int
)processResults.size
();
m_result.successfulProcesses++;
m_logger.info
("进程 " + intToString
(i
) + " 完成: " +
intToString
((int
)processResults.size
()) + " 个结果", "AnalysisProcessManager"
);
}
else {
m_logger.error
("读取进程 " + intToString
(i
) + " 结果失败", "AnalysisProcessManager"
);
m_result.failedProcesses++;
}
}
else if
(m_workerProcesses[i].status == PROCESS_TIMEOUT
) {
m_logger.error
("进程 " + intToString
(i
) + " 超时", "AnalysisProcessManager"
);
m_result.timeoutProcesses++;
}
else if
(m_workerProcesses[i].status == PROCESS_FAILED
) {
m_logger.error
("进程 " + intToString
(i
) + " 失败", "AnalysisProcessManager"
);
m_result.failedProcesses++;
}
}
// 记录总执行时间
m_result.totalExecutionTimeMs = GetTickCount
() - m_startTime;
// 判断总体状态
if
(m_result.successfulProcesses > 0
)
{
m_result.overallStatus = PROCESS_COMPLETED;
m_logger.info
("多进程干涉检查完成: " + intToString
(m_result.successfulProcesses
) +
"/" + intToString
(m_config.processCount
) + " 个进程成功, " +
intToString
((int
)resultList.size
()) + " 个干涉结果, 耗时: " +
formatTimeMs
(m_result.totalExecutionTimeMs
), "AnalysisProcessManager"
);
}
else
{
m_result.overallStatus = PROCESS_FAILED;
m_result.errorMessage = "所有工作进程都失败了";
m_logger.error
(m_result.errorMessage, "AnalysisProcessManager"
);
}
// 清理临时文件
if
(m_config.cleanupTempFiles
)
{
cleanupTempFiles
();
}
return
(m_result.overallStatus == PROCESS_COMPLETED
);
}
void AnalysisProcessManager::splitTasksToProcesses
(const std::vector<std::string>& objectHandles,int processCount,std::vector<std::vector<ObjectHandlePair> >& processTasks
)
{
// 验证输入
if
(objectHandles.empty
()) {
m_logger.error
("对象句柄列表为空", "AnalysisProcessManager"
);
return;
}
// 检查重复和空句柄
std::set<std::string> uniqueHandles;
int emptyHandles = 0;
for
(size_t i = 0; i < objectHandles.size
(); ++i
) {
const std::string& handle = objectHandles[i];
if
(handle.empty
()) {
emptyHandles++;
}
else {
uniqueHandles.insert
(handle
);
}
}
if
(emptyHandles > 0
)
{
m_logger.warn
("发现 " + intToString
(emptyHandles
) + " 个空对象句柄", "AnalysisProcessManager"
);
}
m_logger.info
("对象统计: 总数=" + intToString
((int
)objectHandles.size
()) + ", 唯一=" + intToString
((int
)uniqueHandles.size
()) + ", 空值=" + intToString
(emptyHandles
), "AnalysisProcessManager"
);
// 生成所有对象句柄对
std::vector<ObjectHandlePair> allPairs;
int validPairs = 0;
for
(int i = 0; i <
(int
)objectHandles.size
() - 1; ++i
) {
for
(int j = i + 1; j <
(int
)objectHandles.size
(); ++j
) {
// 跳过无效对
if
(objectHandles[i].empty
() || objectHandles[j].empty
()) {
continue;
}
if
(objectHandles[i] == objectHandles[j]
) {
continue;
}
allPairs.push_back
(std::make_pair
(objectHandles[i], objectHandles[j]
));
validPairs++;
}
}
m_logger.info
("任务对统计: 理论总数=" + intToString
((int
)objectHandles.size
() *
((int
)objectHandles.size
() - 1
) / 2
) +
", 有效对=" + intToString
(validPairs
), "AnalysisProcessManager"
);
if
(allPairs.empty
())
{
m_logger.error
("没有有效的任务对可分配", "AnalysisProcessManager"
);
return;
}
// 均匀分配到各个进程
int pairsPerProcess =
(int
)allPairs.size
() / processCount;
int remainder =
(int
)allPairs.size
() % processCount;
m_logger.info
("任务分配: 每进程基础数=" + intToString
(pairsPerProcess
) +
", 余数=" + intToString
(remainder
), "AnalysisProcessManager"
);
int startIndex = 0;
for
(int i = 0; i < processCount; ++i
)
{
int count = pairsPerProcess +
(i < remainder ? 1 : 0
);
if
(count == 0
)
{
m_logger.warn
("进程 " + intToString
(i
) + " 没有分配到任务", "AnalysisProcessManager"
);
continue;
}
processTasks[i].assign
(allPairs.begin
() + startIndex, allPairs.begin
() + startIndex + count
);
startIndex += count;
m_logger.info
("进程 " + intToString
(i
) + " 分配 " + intToString
(count
) + " 个任务",
"AnalysisProcessManager"
);
}
}
bool AnalysisProcessManager::createWorkerProcess
(int processId, const std::vector<ObjectHandlePair>& tasks, int threadsPerProcess
) {
// 创建任务文件
std::string taskFile = m_config.tempFileDirectory + "/task_" + intToString
(processId
) + ".dat";
std::string resultFile = m_config.tempFileDirectory + "/result_" + intToString
(processId
) + ".dat";
if
(!writeTaskFile
(taskFile, tasks
)) {
m_logger.error
("创建任务文件失败: " + taskFile, "AnalysisProcessManager"
);
return false;
}
// 准备进程启动信息
STARTUPINFOA si;
PROCESS_INFORMATION pi;
ZeroMemory
(&si, sizeof
(si
));
si.cb = sizeof
(si
);
ZeroMemory
(&pi, sizeof
(pi
));
// 构建命令行
std::string commandLine = m_config.workerExecutable + " ";
commandLine += "\"" + taskFile + "\" ";
commandLine += "\"" + resultFile + "\" ";
commandLine += intToString
(threadsPerProcess
);
// 创建命令行缓冲区
char* cmdLine = new char[commandLine.size
() + 1];
strcpy_s
(cmdLine, commandLine.size
() + 1, commandLine.c_str
());
// 创建进程
BOOL success = CreateProcessA
(
NULL,
cmdLine,
NULL,
NULL,
FALSE,
CREATE_NEW_CONSOLE,
NULL,
NULL,
&si,
&pi
);
delete[] cmdLine;
if
(success
) {
// 保存进程信息
m_workerProcesses[processId].processId = processId;
m_workerProcesses[processId].procInfo = pi;
m_workerProcesses[processId].taskFile = taskFile;
m_workerProcesses[processId].resultFile = resultFile;
m_workerProcesses[processId].status = PROCESS_RUNNING;
m_workerProcesses[processId].startTime = GetTickCount
();
m_workerProcesses[processId].endTime = 0;
m_workerProcesses[processId].tasksAssigned =
(int
)tasks.size
();
m_workerProcesses[processId].resultsReturned = 0;
logProcessEvent
(processId, "进程启动成功"
);
return true;
}
else {
DWORD error = GetLastError
();
m_logger.error
("创建进程失败，错误码: " + intToString
((int
)error
), "AnalysisProcessManager"
);
return false;
}
}
bool AnalysisProcessManager::writeTaskFile
(const std::string& taskFile, const std::vector<ObjectHandlePair>& tasks
) {
// 确保临时目录存在
CreateDirectoryA
(m_config.tempFileDirectory.c_str
(), NULL
);
std::ofstream file
(taskFile.c_str
(), std::ios::binary
);
if
(!file.is_open
()) {
return false;
}
// 写入任务数量
int taskCount =
(int
)tasks.size
();
file.write
(reinterpret_cast<const char*>
(&taskCount
), sizeof
(int
));
// 写入任务数据（对象句柄对）
for
(int i = 0; i < taskCount; ++i
) {
writeString
(file, tasks[i].first
); // 第一个对象句柄
writeString
(file, tasks[i].second
); // 第二个对象句柄
}
file.close
();
m_logger.info
("任务文件生成完成: " + taskFile + "
(" + intToString
(taskCount
) + " 个任务
)",
"AnalysisProcessManager"
);
return true;
}
bool AnalysisProcessManager::readResultFile
(const std::string& resultFile, std::vector<InterferenceResult>& resultList
) {
// 首先检查文件是否存在
DWORD fileAttributes = GetFileAttributesA
(resultFile.c_str
());
if
(fileAttributes == INVALID_FILE_ATTRIBUTES
) {
m_logger.error
("结果文件不存在: " + resultFile, "AnalysisProcessManager"
);
return false;
}
// 检查文件
大小
WIN32_FILE_ATTRIBUTE_DATA fileInfo;
if
(!GetFileAttributesExA
(resultFile.c_str
(), GetFileExInfoStandard, &fileInfo
)) {
m_logger.error
("无法获取结果文件信息: " + resultFile, "AnalysisProcessManager"
);
return false;
}
LARGE_INTEGER fileSize;
fileSize.LowPart = fileInfo.nFileSizeLow;
fileSize.HighPart = fileInfo.nFileSizeHigh;
if
(fileSize.QuadPart == 0
) {
m_logger.warn
("结果文件为空: " + resultFile, "AnalysisProcessManager"
);
return true; // 空文件不算错误，只是没有结果
}
std::ifstream file
(resultFile.c_str
(), std::ios::binary
);
if
(!file.is_open
()) {
m_logger.error
("无法打开结果文件: " + resultFile, "AnalysisProcessManager"
);
return false;
}
try {
// 读取结果数量
int resultCount = 0;
file.read
(reinterpret_cast<char*>
(&resultCount
), sizeof
(int
));
if
(resultCount < 0
) {
m_logger.error
("结果文件格式错误: 结果数量为负数 " + intToString
(resultCount
),
"AnalysisProcessManager"
);
file.close
();
return false;
}
if
(resultCount > 1000000
) { // 合理的上限
m_logger.error
("结果文件格式错误: 结果数量异常 " + intToString
(resultCount
),
"AnalysisProcessManager"
);
file.close
();
return false;
}
m_logger.info
("从文件 " + resultFile + " 读取 " + intToString
(resultCount
) + " 个结果",
"AnalysisProcessManager"
);
// 读取结果数据
for
(int i = 0; i < resultCount; ++i
)
{
InterferenceResult result;
file.read
(reinterpret_cast<char*>
(&result
), sizeof
(InterferenceResult
));
// 简单验证结果数据
if
(result.obj1 == NULL || result.obj2 == NULL
)
{
m_logger.warn
("跳过无效的干涉结果: 对象标签为空", "AnalysisProcessManager"
);
continue;
}
resultList.push_back
(result
);
}
file.close
();
return true;
}
catch
(const std::exception& e
) {
m_logger.error
("读取结果文件异常: " + std::string
(e.what
()) + "
(文件: " + resultFile + "
)",
"AnalysisProcessManager"
);
if
(file.is_open
()) {
file.close
();
}
return false;
}
catch
(...
) {
m_logger.error
("未知读取结果文件异常
(文件: " + resultFile + "
)", "AnalysisProcessManager"
);
if
(file.is_open
()) {
file.close
();
}
return false;
}
}
void AnalysisProcessManager::monitorProcesses
() {
m_logger.info
("开始监控工作进程状态", "AnalysisProcessManager"
);
DWORD lastReportTime = GetTickCount
();
int runningProcesses = m_config.processCount;
while
(runningProcesses > 0 && !m_stopRequested
) {
runningProcesses = 0;
for
(int i = 0; i < m_config.processCount; ++i
) {
if
(m_workerProcesses[i].status == PROCESS_RUNNING
) {
if
(!waitForProcessCompletion
(m_workerProcesses[i]
)) {
runningProcesses++;
}
}
}
// 定期报告状态
DWORD currentTime = GetTickCount
();
if
(currentTime - lastReportTime >= 5000
) {
int completed = 0;
for
(int i = 0; i < m_config.processCount; ++i
) {
if
(m_workerProcesses[i].status == PROCESS_COMPLETED
) {
completed++;
}
}
m_logger.info
("进程监控: " + intToString
(completed
) + "/" +
intToString
(m_config.processCount
) + " 个进程完成",
"AnalysisProcessManager"
);
lastReportTime = currentTime;
}
if
(runningProcesses > 0
) {
Sleep
(1000
);
}
}
m_logger.info
("进程监控结束", "AnalysisProcessManager"
);
}
bool AnalysisProcessManager::waitForProcessCompletion
(WorkerProcessInfo& processInfo
) {
DWORD result = WaitForSingleObject
(processInfo.procInfo.hProcess, 0
);
if
(result == WAIT_OBJECT_0
) {
processInfo.status = PROCESS_COMPLETED;
processInfo.endTime = GetTickCount
();
DWORD exitCode;
GetExitCodeProcess
(processInfo.procInfo.hProcess, &exitCode
);
// 详细记录退出码
std::string exitInfo = "进程正常结束，退出码: " + intToString
((int
)exitCode
);
if
(exitCode == 0xC0000005
) {
exitInfo += "
(访问冲突 - Access Violation
)";
}
else if
(exitCode == 0xC00000FD
) {
exitInfo += "
(栈溢出 - Stack Overflow
)";
}
else if
(exitCode != 0
) {
exitInfo += "
(异常退出
)";
}
logProcessEvent
(processInfo.processId, exitInfo
);
CloseHandle
(processInfo.procInfo.hProcess
);
CloseHandle
(processInfo.procInfo.hThread
);
return true;
}
else if
(result == WAIT_TIMEOUT
) {
DWORD currentTime = GetTickCount
();
if
(currentTime - processInfo.startTime > m_config.processTimeoutMs
) {
processInfo.status = PROCESS_TIMEOUT;
processInfo.endTime = currentTime;
TerminateProcess
(processInfo.procInfo.hProcess, 1
);
CloseHandle
(processInfo.procInfo.hProcess
);
CloseHandle
(processInfo.procInfo.hThread
);
logProcessEvent
(processInfo.processId, "进程超时终止"
);
return true;
}
}
return false;
}
void AnalysisProcessManager::terminateAllProcesses
() {
m_stopRequested = true;
for
(size_t i = 0; i < m_workerProcesses.size
(); ++i
) {
if
(m_workerProcesses[i].status == PROCESS_RUNNING
) {
TerminateProcess
(m_workerProcesses[i].procInfo.hProcess, 1
);
CloseHandle
(m_workerProcesses[i].procInfo.hProcess
);
CloseHandle
(m_workerProcesses[i].procInfo.hThread
);
m_workerProcesses[i].status = PROCESS_FAILED;
m_workerProcesses[i].endTime = GetTickCount
();
logProcessEvent
(m_workerProcesses[i].processId, "进程被强制终止"
);
}
}
m_logger.info
("所有工作进程已终止", "AnalysisProcessManager"
);
}
void AnalysisProcessManager::cleanupTempFiles
() {
for
(size_t i = 0; i < m_workerProcesses.size
(); ++i
) {
if
(!m_workerProcesses[i].taskFile.empty
()) {
DeleteFileA
(m_workerProcesses[i].taskFile.c_str
());
}
if
(!m_workerProcesses[i].resultFile.empty
()) {
DeleteFileA
(m_workerProcesses[i].resultFile.c_str
());
}
}
RemoveDirectoryA
(m_config.tempFileDirectory.c_str
());
}
bool AnalysisProcessManager::checkWorkerExecutable
() {
DWORD attributes = GetFileAttributesA
(m_config.workerExecutable.c_str
());
return
(attributes != INVALID_FILE_ATTRIBUTES && !
(attributes & FILE_ATTRIBUTE_DIRECTORY
));
}
void AnalysisProcessManager::logProcessEvent
(int processId, const std::string& event
) {
m_logger.info
("进程 " + intToString
(processId
) + ": " + event, "ProcessMonitor"
);
}
ProcessExecutionStatus AnalysisProcessManager::getProcessStatus
(int processId
) const {
if
(processId >= 0 && processId <
(int
)m_workerProcesses.size
()) {
return m_workerProcesses[processId].status;
}
return PROCESS_NOT_STARTED;
}
std::vector<WorkerProcessInfo> AnalysisProcessManager::getAllProcessStatus
() const {
return m_workerProcesses;
}
void AnalysisProcessManager::calculateOptimalConfiguration
(int totalTasks, int& processCount, int& threadsPerProcess
) {
SYSTEM_INFO sysInfo;
GetSystemInfo
(&sysInfo
);
int cpuCount = sysInfo.dwNumberOfProcessors;
if
(totalTasks < 1000
) {
processCount = 1;
threadsPerProcess =
(8 < cpuCount * 2
) ? 8 : cpuCount * 2;
}
else if
(totalTasks < 10000
) {
processCount =
(2 < cpuCount
) ? 2 : cpuCount;
threadsPerProcess =
(6 <
(cpuCount * 2
) / processCount
) ? 6 :
(cpuCount * 2
) / processCount;
}
else if
(totalTasks < 100000
) {
processCount =
(4 < cpuCount
) ? 4 : cpuCount;
threadsPerProcess =
(4 <
(cpuCount * 2
) / processCount
) ? 4 :
(cpuCount * 2
) / processCount;
}
else {
processCount =
(8 < cpuCount
) ? 8 : cpuCount;
threadsPerProcess =
(4 <
(cpuCount * 2
) / processCount
) ? 4 :
(cpuCount * 2
) / processCount;
}
processCount =
(processCount < 1
) ? 1 : processCount;
threadsPerProcess =
(threadsPerProcess < 1
) ? 1 : threadsPerProcess;
}
std::string AnalysisProcessManager::generateProcessReport
() const {
std::stringstream report;
report << "=== 进程管理报告 ===" << std::endl;
report << "总体状态: ";
switch
(m_result.overallStatus
) {
case PROCESS_NOT_STARTED: report << "未开始"; break;
case PROCESS_RUNNING: report << "执行中"; break;
case PROCESS_COMPLETED: report << "完成"; break;
case PROCESS_FAILED: report << "失败"; break;
case PROCESS_TIMEOUT: report << "超时"; break;
}
report << std::endl;
report << "总执行时间: " << formatTimeMs
(m_result.totalExecutionTimeMs
) << std::endl;
report << "进程统计: " << m_result.successfulProcesses << " 成功, "
<< m_result.failedProcesses << " 失败, "
<< m_result.timeoutProcesses << " 超时" << std::endl;
report << "任务统计: " << m_result.totalResultsCollected << "/"
<< m_result.totalTasksAssigned << " 个结果" << std::endl;
report << std::endl;
report << "详细进程状态:" << std::endl;
for
(size_t i = 0; i < m_workerProcesses.size
(); ++i
) {
const WorkerProcessInfo& proc = m_workerProcesses[i];
report << " 进程 " << proc.processId << ": ";
switch
(proc.status
) {
case PROCESS_NOT_STARTED: report << "未开始"; break;
case PROCESS_RUNNING: report << "执行中"; break;
case PROCESS_COMPLETED: report << "完成"; break;
case PROCESS_FAILED: report << "失败"; break;
case PROCESS_TIMEOUT: report << "超时"; break;
}
if
(proc.startTime > 0
) {
DWORD duration =
(proc.endTime > 0 ? proc.endTime - proc.startTime : GetTickCount
() - proc.startTime
);
report << "
(运行: " << formatTimeMs
(duration
) << "
)";
}
report << " - 任务: " << proc.tasksAssigned << ", 结果: " << proc.resultsReturned;
report << std::endl;
}
if
(!m_result.errorMessage.empty
()) {
report << std::endl;
report << "错误信息: " << m_result.errorMessage << std::endl;
}
return report.str
();
}
/*****************************************************************************
**
** AnalysisProcessManager.cpp
**
** Description:
** Main file for the application.
**
*****************************************************************************/
/* Include files */
#if ! defined
( __hp9000s800
) && ! defined
( __sgi
) && ! defined
( __sun
)
# include <strstream>
# include <iostream>
using std::ostrstream;
using std::endl;
using std::ends;
using std::cerr;
#else
# include <strstream.h>
# include <iostream.h>
#endif
#include <uf.h>
#include "AnalysisProcessManager.h"
#include <NXOpen/Part.hxx>
#include <NXOpen/NXObjectManager.hxx>
#include "../comon/customNxTools.h"
#include "uf_part.h"
#define UF_CALL
(X
) (report_error
( __FILE__, __LINE__, #X,
(X
)))
static int report_error
( char *file, int line, char *call, int irc
)
{
if
(irc
)
{
char err[133],
msg[133];
sprintf
(msg, "*** ERROR code %d at line %d in %s:\n+++ ",
irc, line, file
);
UF_get_fail_message
(irc, err
);
UF_print_syslog
(msg, FALSE
);
UF_print_syslog
(err, FALSE
);
UF_print_syslog
("\n", FALSE
);
UF_print_syslog
(call, FALSE
);
UF_print_syslog
(";\n", FALSE
);
}
return
(irc
);
}
/* Main routine */
extern void main
( char argc, char *argv[]
)
{
/* Initialize the API environment */
if
( UF_CALL
(UF_initialize
()) )
{
/* Failed to initialize */
return;
}
// 原来的代码
std::string client = "C:\\Users\\JXKT-23055\\Desktop\\FetrueModl\\JAC-X243-HSTD250129-DIE-REV01\\JAC-X243-HSTD250129-DIE-REV01.prt";
std::cout << client << std::endl;
UF_PART_load_status_t error_status;
tag_t partTag;
UF_PART_open
((char*
)client.c_str
(), &partTag, &error_status
);
if
(partTag == NULL
)
{
std::cout << "partTag Null" << std::endl;
return;
}
NXOpen::Part* part = dynamic_cast<NXOpen::Part*>
(NXOpen::NXObjectManager::Get
(partTag
));
part->LoadFully
();
// 新的多进程调用方式
std::vector<int> vecLayers;
for
(int i = 1; i <= 8; i++
)
{
vecLayers.push_back
(i
);
}
// 创建进程管理器
AnalysisProcessManager processManager;
// 读取图层对象（使用你现有的LayerReader）
LayerReader layerReader;
std::vector<tag_t> objects = layerReader.readLayersInParallel
(vecLayers, true
);
vector<string>vecObjectHandle;
for
(size_t i = 0; i < objects.size
(); i++
)
{
char* tempHandle = UF_TAG_ask_handle_of_tag
(objects[i]
);
if
(tempHandle
)
{
vecObjectHandle.push_back
(std::string
(tempHandle
));
UF_free
(tempHandle
);
}
}
// 执行多进程干涉检查
std::vector<InterferenceResult> results;
bool success = processManager.performMultiProcessInterferenceCheck
(
vecObjectHandle,
results,
0, // 进程数量，可以改为0自动计算
0 // 每个进程的线程数，可以改为0自动计算
);
if
(success
) {
std::cout << "多进程干涉检查完成，发现 " << results.size
() << " 个干涉" << std::endl;
auto CopyObjectNX = [&]
(tag_t objTag
)->tag_t
{
vector<tag_t>vObjs;
vObjs.push_back
(objTag
);
if
(vObjs.empty
()) return NULL;
Session* theSession = Session::GetSession
();
Part* workPart
(theSession->Parts
()->Work
());
Part* displayPart
(theSession->Parts
()->Display
());
Features::MoveObject* nullFeatures_MoveObject
(NULL
);
Features::MoveObjectBuilder* moveObjectBuilder1;
moveObjectBuilder1 = workPart->BaseFeatures
()->CreateMoveObjectBuilder
(nullFeatures_MoveObject
);
moveObjectBuilder1->TransformMotion
()->DistanceAngle
()->OrientXpress
()->SetAxisOption
(GeometricUtilities::OrientXpressBuilder::AxisPassive
);
moveObjectBuilder1->TransformMotion
()->DistanceAngle
()->OrientXpress
()->SetPlaneOption
(GeometricUtilities::OrientXpressBuilder::PlanePassive
);
moveObjectBuilder1->TransformMotion
()->AlongCurveAngle
()->AlongCurve
()->SetPercentUsed
(true
);
moveObjectBuilder1->TransformMotion
()->AlongCurveAngle
()->AlongCurve
()->Expression
()->SetRightHandSide
("0"
);
Point3d manipulatororigin1;
manipulatororigin1 = moveObjectBuilder1->TransformMotion
()->ManipulatorOrigin
();
Matrix3x3 manipulatormatrix1;
manipulatormatrix1 = moveObjectBuilder1->TransformMotion
()->ManipulatorMatrix
();
moveObjectBuilder1->TransformMotion
()->SetOption
(GeometricUtilities::ModlMotion::OptionsDynamic
);
moveObjectBuilder1->TransformMotion
()->DistanceValue
()->SetRightHandSide
("0"
);
moveObjectBuilder1->TransformMotion
()->DistanceBetweenPointsDistance
()->SetRightHandSide
("0"
);
moveObjectBuilder1->TransformMotion
()->RadialDistance
()->SetRightHandSide
("0"
);
moveObjectBuilder1->TransformMotion
()->Angle
()->SetRightHandSide
("0"
);
moveObjectBuilder1->TransformMotion
()->DistanceAngle
()->Distance
()->SetRightHandSide
("0"
);
moveObjectBuilder1->TransformMotion
()->DistanceAngle
()->Angle
()->SetRightHandSide
("0"
);
moveObjectBuilder1->TransformMotion
()->SetDelta
Enum(GeometricUtilities::ModlMotion::DeltaReferenceWcsWorkPart
);
moveObjectBuilder1->TransformMotion
()->DeltaXc
()->SetRightHandSide
("0"
);
moveObjectBuilder1->TransformMotion
()->DeltaYc
()->SetRightHandSide
("0"
);
moveObjectBuilder1->TransformMotion
()->DeltaZc
()->SetRightHandSide
("0"
);
moveObjectBuilder1->TransformMotion
()->AlongCurveAngle
()->AlongCurve
()->Expression
()->SetRightHandSide
("0"
);
moveObjectBuilder1->TransformMotion
()->AlongCurveAngle
()->AlongCurveAngle
()->SetRightHandSide
("0"
);
moveObjectBuilder1->SetMoveObjectResult
(Features::MoveObjectBuilder::MoveObjectResultOptionsCopyOriginal
);
bool added1;
vector<NXObject*> vecNxobj;
for
(size_t i = 0; i < vObjs.size
(); i++
)
{
vecNxobj.push_back
(dynamic_cast<NXObject*>
(NXObjectManager::Get
(vObjs[i]
)));
}
added1 = moveObjectBuilder1->ObjectToMoveObject
()->Add
(vecNxobj
);
Point3d manipulatororigin2;
manipulatororigin2 = moveObjectBuilder1->TransformMotion
()->ManipulatorOrigin
();
Matrix3x3 manipulatormatrix2;
manipulatormatrix2 = moveObjectBuilder1->TransformMotion
()->ManipulatorMatrix
();
NXObject* nXObject1;
nXObject1 = moveObjectBuilder1->Commit
();
std::vector<NXObject*> objects1;
objects1 = moveObjectBuilder1->GetCommittedObjects
();
moveObjectBuilder1->Destroy
();
tag_t zz = objects1.front
()->Tag
();
return zz;
};
// 生成报告
std::string report = processManager.generateProcessReport
();
std::cout << report << std::endl;
/* for
(size_t i = 0; i < results.size
(); i++
)
{
tag_t resultTag1 = UF_TAG_ask_tag_of_handle
((char*
)results[i].obj1.c_str
());
tag_t resultTag2 = UF_TAG_ask_tag_of_handle
((char*
)results[i].obj2.c_str
());
if
(resultTag1 != NULL && resultTag2 != NULL
)
{
CopyObjectNX
(resultTag1
);
CopyObjectNX
(resultTag2
);
}
}*/
}
else {
std::cout << "多进程干涉检查失败" << std::endl;
}
/* TODO: Add your application code here */
system
("pause"
);
/* Terminate the API environment */
UF_CALL
(UF_terminate
());
}
/*****************************************************************************
** Utilities
*****************************************************************************/
以上是多进程管理程序的设计，将其改内存共享模式
#include "ThreadPool.h"
#include "../comon/CheckSystem.h"
#include "../comon/Logger.h"
#include "../comon/customNxTools.h"
#include <uf_obj.h>
#include <iostream>
#include <fstream>
#include <vector>
#include <string>
#include <queue>
#include <set>
#include <uf_part.h>
// 字符串读取辅助函数
std::string readString
(std::ifstream& file
) {
int length = 0;
file.read
(reinterpret_cast<char*>
(&length
), sizeof
(int
));
if
(length > 0
) {
std::vector<char> buffer
(length + 1
);
file.read
(&buffer[0], length
);
buffer[length] = '\0';
return std::string
(&buffer[0]
);
}
return "";
}
// 失败任务重试管理器
class FailedTaskManager {
public:
struct FailedTask {
std::string handle1;
std::string handle2;
int retryCount;
};
FailedTaskManager
(CRITICAL_SECTION* cs, Logger* logger
)
: m_cs
(cs
), m_logger
(logger
), m_maxRetries
(3
) {}
void addFailedTask
(const std::string& handle1, const std::string& handle2, int retryCount = 0
) {
EnterCriticalSection
(m_cs
);
try {
FailedTask task;
task.handle1 = handle1;
task.handle2 = handle2;
task.retryCount = retryCount;
m_failedTasks.push
(task
);
m_logger->debug
("添加失败任务到重试队列: " + handle1 + " - " + handle2 +
"
(重试次数: " + intToString
(retryCount
) + "
)", "FailedTaskManager"
);
}
catch
(...
) {
LeaveCriticalSection
(m_cs
);
throw;
}
LeaveCriticalSection
(m_cs
);
}
bool getNextFailedTask
(FailedTask& task
) {
EnterCriticalSection
(m_cs
);
bool hasTask = false;
if
(!m_failedTasks.empty
()) {
task = m_failedTasks.front
();
m_failedTasks.pop
();
hasTask = true;
}
LeaveCriticalSection
(m_cs
);
return hasTask;
}
bool hasFailedTasks
() {
EnterCriticalSection
(m_cs
);
bool hasTasks = !m_failedTasks.empty
();
LeaveCriticalSection
(m_cs
);
return hasTasks;
}
size_t getFailedTaskCount
() {
EnterCriticalSection
(m_cs
);
size_t count = m_failedTasks.size
();
LeaveCriticalSection
(m_cs
);
return count;
}
int getMaxRetries
() const { return m_maxRetries; }
private:
std::queue<FailedTask> m_failedTasks;
CRITICAL_SECTION* m_cs;
Logger* m_logger;
const int m_maxRetries;
};
double getVolumeByBody
(tag_t bodyTag
)
{
int num_objs = 1;
int type = 1;
int units = 3;
double density = 0.0;
int accuracy = 1;
double acc_value[11] = { 0 };
double mass_props[47] = { 0 };
double statistics[13] = { 0 };
UF_CALL
(UF_MODL_ask_mass_props_3d
(
&bodyTag,
num_objs,
type,
units,
density,
accuracy,
acc_value,
mass_props,
statistics
));
return mass_props[1];
}
double getInterferenceBodyVolume
(tag_t objTag1, tag_t objTag2
)
{
Session* theSession = Session::GetSession
();
Part* workPart
(theSession->Parts
()->Work
());
GeometricAnalysis::SimpleInterference* simpleInterference1;
simpleInterference1 = workPart->AnalysisManager
()->CreateSimpleInterferenceObject
();
simpleInterference1->SetInterferenceType
(GeometricAnalysis::SimpleInterference::InterferenceMethodInterferenceSolid
);
simpleInterference1->SetFaceInterferenceType
(GeometricAnalysis::SimpleInterference::FaceInterferenceMethodFirstPairOnly
);
Body* body1
(dynamic_cast<Body*>
(NXOpen::NXObjectManager::Get
(objTag1
)));
simpleInterference1->FirstBody
()->SetValue
(body1
);
Body* body2
(dynamic_cast<Body*>
(NXOpen::NXObjectManager::Get
(objTag2
)));
simpleInterference1->SecondBody
()->SetValue
(body2
);
GeometricAnalysis::SimpleInterference::Result result1;
result1 = simpleInterference1->PerformCheck
();
NXObject* nXObject1;
nXObject1 = simpleInterference1->Commit
();
double volume = 0.0;
if
(NXOpen::GeometricAnalysis::SimpleInterference::Result::ResultInterferenceExists == result1
) {
std::vector<NXObject*> vecNXObjs = simpleInterference1->GetInterferenceResults
();
for
(int i = 0; i < vecNXObjs.size
(); ++i
) {
double value = getVolumeByBody
(vecNXObjs[i]->Tag
());
volume += value;
UF_OBJ_delete_object
(vecNXObjs[i]->Tag
());
}
}
simpleInterference1->Destroy
();
return volume;
}
// 改进的工作进程任务类（支持重试）
class AnalysisTask : public Task {
public:
AnalysisTask
(const std::string& handle1, const std::string& handle2,
std::vector<InterferenceResult>* resultList,
CRITICAL_SECTION* resultCs,
FailedTaskManager* failedTaskManager,
Logger* logger,
int retryCount = 0
)
: m_handle1
(handle1
), m_handle2
(handle2
),
m_resultList
(resultList
), m_resultCs
(resultCs
),
m_failedTaskManager
(failedTaskManager
),
m_logger
(logger
), m_retryCount
(retryCount
) {}
virtual void execute
() {
bool taskFailed = false;
std::string errorMsg;
// 验证输入参数
if
(m_handle1.empty
() || m_handle2.empty
()) {
m_logger->warn
("任务跳过: 对象句柄为空
(" + m_handle1 + ", " + m_handle2 + "
)", "AnalysisTask"
);
return;
}
if
(m_handle1 == m_handle2
) {
m_logger->warn
("任务跳过: 相同对象
(" + m_handle1 + "
)", "AnalysisTask"
);
return;
}
if
(UF_initialize
())return;
try {
// 将对象句柄转换回tag_t
tag_t resultTag1 = UF_TAG_ask_tag_of_handle
((char*
)m_handle1.c_str
());
tag_t resultTag2 = UF_TAG_ask_tag_of_handle
((char*
)m_handle2.c_str
());
if
(resultTag1 != NULL_TAG && resultTag2 != NULL_TAG
) {
// 分析对象属性
ObjectProperty prop1, prop2;
try {
prop1 = MaterialAnalyzer::analyzeObject
(resultTag1
);
prop2 = MaterialAnalyzer::analyzeObject
(resultTag2
);
}
catch
(const std::exception& e
) {
errorMsg = "对象属性分析失败: " + std::string
(e.what
());
taskFailed = true;
}
catch
(...
) {
errorMsg = "未知对象属性分析错误";
taskFailed = true;
}
if
(!taskFailed
) {
// 计算距离
double distance = 0.0;
try {
PK_TwoObjectDist
(resultTag1, resultTag2, distance
);
if
(distance > 0.1
) {
return;
}
}
catch
(const std::exception& e
)
{
m_logger->warn
("距离计算失败: " + std::string
(e.what
()) +
"
(对象: " + m_handle1 + ", " + m_handle2 + "
)", "AnalysisTask"
);
// 距离计算失败不影响继续执行干涉检查
}
catch
(...
) {
m_logger->warn
("未知距离计算错误
(对象: " + m_handle1 + ", " + m_handle2 + "
)",
"AnalysisTask"
);
// 距离计算失败不影响继续执行干涉检查
}
// 检查干涉
bool hasInterference = false;
try {
hasInterference = checkInterferenceTest
(resultTag1, resultTag2
);
auto CopyObject = [&]
(tag_t objTag
)->tag_t
{
tag_t arr[1] = { objTag };
tag_t* old_parents = NULL;
tag_t* new_parents = NULL;
int parent_count = 0;
parent_count = 0;
tag_t* new_features = NULL;
int result = UF_MODL_copy_paste_features
(arr,1,old_parents,new_parents,parent_count,1, 0,&new_features
);
if
(result != 0 || new_features == NULL
) return NULL_TAG;
tag_t new_feature = new_features[0];
cout << "复制成功" << endl;
UF_free
(new_features
);
return new_feature;
};
/* double volume = getInterferenceBodyVolume
(resultTag1, resultTag2
);
if
(volume>0.01
)
{
hasInterference = true;
}*/
}
catch
(const std::exception& e
) {
errorMsg = "干涉检查失败: " + std::string
(e.what
());
taskFailed = true;
}
catch
(...
) {
errorMsg = "未知干涉检查错误";
taskFailed = true;
}
if
(!taskFailed && hasInterference
)
{
EnterCriticalSection
(m_resultCs
);
try {
m_resultList->push_back
(InterferenceResult
(resultTag1, resultTag2, prop1, prop2
));
}
catch
(const std::exception& e
)
{
LeaveCriticalSection
(m_resultCs
);
errorMsg = "保存结果失败: " + std::string
(e.what
());
taskFailed = true;
}
LeaveCriticalSection
(m_resultCs
);
}
else if
(!taskFailed
)
{
m_logger->debug
("无干涉: " + m_handle1 + " - " + m_handle2 + "
(距离: " + doubleToString
(distance
) + "
)", "AnalysisTask"
);
}
}
}
else
{
// 对象句柄转换失败
if
(resultTag1 == NULL_TAG
)
{
errorMsg = "无法获取对象1的tag，句柄: " + m_handle1;
}
if
(resultTag2 == NULL_TAG
) {
if
(!errorMsg.empty
()) errorMsg += "; ";
errorMsg += "无法获取对象2的tag，句柄: " + m_handle2;
}
taskFailed = true;
}
}
catch
(const std::exception& e
) {
errorMsg = "AnalysisTask执行异常: " + std::string
(e.what
());
taskFailed = true;
}
catch
(...
) {
errorMsg = "AnalysisTask未知异常";
taskFailed = true;
}
UF_terminate
();
// 处理任务失败情况
if
(taskFailed
) {
m_logger->error
(errorMsg + "
(对象: " + m_handle1 + ", " + m_handle2 +
", 重试次数: " + intToString
(m_retryCount
) + "
)", "AnalysisTask"
);
// 如果重试次数未达到上限，将任务添加到重试队列
if
(m_retryCount < m_failedTaskManager->getMaxRetries
()) {
m_failedTaskManager->addFailedTask
(m_handle1, m_handle2, m_retryCount + 1
);
m_logger->info
("任务已加入重试队列: " + m_handle1 + " - " + m_handle2 +
"
(下次重试次数: " + intToString
(m_retryCount + 1
) + "
)", "AnalysisTask"
);
}
else {
m_logger->error
("任务达到最大重试次数，放弃: " + m_handle1 + " - " + m_handle2,
"AnalysisTask"
);
}
}
}
virtual std::string getName
() const {
return "AnalysisTask[" + m_handle1 + "," + m_handle2 +
"]
(retry:" + intToString
(m_retryCount
) + "
)";
}
private:
std::string m_handle1;
std::string m_handle2;
std::vector<InterferenceResult>* m_resultList;
CRITICAL_SECTION* m_resultCs;
FailedTaskManager* m_failedTaskManager;
Logger* m_logger;
int m_retryCount;
};
// 从文件读取对象句柄任务
bool readHandleTasksFromFile
(const std::string& taskFile, std::vector<std::pair<std::string, std::string>>& tasks
)
{
std::ifstream file
(taskFile.c_str
(), std::ios::binary
);
if
(!file.is_open
()) {
std::cerr << "无法打开任务文件: " << taskFile << std::endl;
return false;
}
int taskCount = 0;
file.read
(reinterpret_cast<char*>
(&taskCount
), sizeof
(int
));
if
(taskCount <= 0
) {
std::cerr << "任务文件格式错误: 任务数量为 " << taskCount << std::endl;
return false;
}
tasks.resize
(taskCount
);
for
(int i = 0; i < taskCount; ++i
)
{
tasks[i].first = readString
(file
); // 第一个对象句柄
tasks[i].second = readString
(file
); // 第二个对象句柄
}
file.close
();
return true;
}
// 写入结果到文件
bool writeResultsToFile
(const std::string& resultFile,
const std::vector<InterferenceResult>& results
) {
std::ofstream file
(resultFile.c_str
(), std::ios::binary
);
if
(!file.is_open
()) {
std::cerr << "无法创建结果文件: " << resultFile << std::endl;
return false;
}
int resultCount =
(int
)results.size
();
file.write
(reinterpret_cast<const char*>
(&resultCount
), sizeof
(int
));
for
(int i = 0; i < resultCount; ++i
) {
file.write
(reinterpret_cast<const char*>
(&results[i]
), sizeof
(InterferenceResult
));
}
file.close
();
return true;
}
// 初始化日志系统
bool initializeLogger
(const std::string& processId
) {
try {
Logger& logger = Logger::getInstance
();
std::string logFile = "logs/analysis_process_" + processId + ".log";
logger.init
(logFile, true, true
);
logger.info
("分析进程 " + processId + " 启动（支持任务重试机制）", "Analysis"
);
return true;
}
catch
(const std::exception& e
) {
std::cerr << "日志初始化失败: " << e.what
() << std::endl;
return false;
}
}
#include <NXOpen/Part.hxx>
#include <NXOpen/NXObjectManager.hxx>
int main
(int argc, char* argv[]
)
{
if
(argc != 4
) {
std::cerr << "用法: Analysis.exe <任务文件> <结果文件> <线程数>" << std::endl;
std::cerr << "参数: " << std::endl;
std::cerr << " 任务文件 - 包含要处理的对象句柄对" << std::endl;
std::cerr << " 结果文件 - 用于输出处理结果" << std::endl;
std::cerr << " 线程数 - 工作线程数量" << std::endl;
return 1;
}
std::string taskFile = argv[1];
std::string resultFile = argv[2];
int threadCount = atoi
(argv[3]
);
if
(UF_initialize
())
{
return 0;
}
std::string client = "C:\\Users\\JXKT-23055\\Desktop\\FetrueModl\\JAC-X243-HSTD250129-DIE-REV01\\JAC-X243-HSTD250129-DIE-REV01.prt";
std::cout << client << std::endl;
UF_PART_load_status_t error_status;
tag_t partTag;
UF_PART_open
((char*
)client.c_str
(), &partTag, &error_status
);
if
(partTag == NULL
) {
std::cout << "partTag Null" << std::endl;
return 0;
}
NXOpen::Part* part = dynamic_cast<NXOpen::Part*>
(NXOpen::NXObjectManager::Get
(partTag
));
part->LoadFully
();
// 生成进程ID
std::string processId = "unknown";
size_t pos = taskFile.find_last_of
("_"
);
if
(pos != std::string::npos
) {
size_t dotPos = taskFile.find_last_of
("."
);
if
(dotPos != std::string::npos
) {
processId = taskFile.substr
(pos + 1, dotPos - pos - 1
);
}
}
// 初始化日志
if
(!initializeLogger
(processId
)) {
return 1;
}
Logger& logger = Logger::getInstance
();
std::cout << "分析进程启动: " << taskFile << " -> " << resultFile
<< "
(线程数: " << threadCount << "
)" << std::endl;
logger.info
("分析进程配置: 任务文件=" + taskFile + ", 结果文件=" + resultFile +
", 线程数=" + intToString
(threadCount
), "Analysis"
);
try {
// 读取对象句柄任务
std::vector<std::pair<std::string, std::string> > tasks;
if
(!readHandleTasksFromFile
(taskFile, tasks
)) {
logger.error
("读取任务文件失败: " + taskFile, "Analysis"
);
return 1;
}
logger.info
("成功读取 " + intToString
(tasks.size
()) + " 个对象句柄对任务", "Analysis"
);
// 检查任务数量
if
(tasks.empty
()) {
logger.warn
("任务文件为空，无需处理", "Analysis"
);
// 创建空的结果文件
writeResultsToFile
(resultFile, std::vector<InterferenceResult>
());
return 0;
}
// 记录前几个任务用于调试
for
(int i = 0; i <
(5 <
(int
)tasks.size
() ? 5 :
(int
)tasks.size
()); ++i
) {
logger.debug
("任务 " + intToString
(i
) + ": " + tasks[i].first + " - " + tasks[i].second,
"Analysis"
);
}
// 初始化结果列表和同步对象
std::vector<InterferenceResult> results;
CRITICAL_SECTION resultCs;
InitializeCriticalSection
(&resultCs
);
// 初始化失败任务管理器
FailedTaskManager failedTaskManager
(&resultCs, &logger
);
// 创建线程池
logger.info
("开始创建线程池: " + intToString
(threadCount
) + " 个线程", "Analysis"
);
ThreadPool pool
(threadCount
);
logger.info
("线程池创建成功", "Analysis"
);
// 提交初始任务
DWORD submitStartTime = GetTickCount
();
int submittedTasks = 0;
int validTasks = 0;
for
(size_t i = 0; i < tasks.size
(); ++i
) {
// 验证任务数据
if
(tasks[i].first.empty
() || tasks[i].second.empty
()) {
logger.warn
("跳过无效任务: 空句柄
(索引: " + intToString
(i
) + "
)", "Analysis"
);
continue;
}
if
(tasks[i].first == tasks[i].second
) {
logger.warn
("跳过无效任务: 相同对象
(索引: " + intToString
(i
) + "
)", "Analysis"
);
continue;
}
Task* task = new AnalysisTask
(tasks[i].first, tasks[i].second, &results, &resultCs,
&failedTaskManager, &logger, 0
);
pool.addTask
(task
);
submittedTasks++;
validTasks++;
// 定期报告提交进度
if
(submittedTasks % 1000 == 0
) {
logger.info
("已提交 " + intToString
(submittedTasks
) + "/" +
intToString
(tasks.size
()) + " 个任务", "Analysis"
);
}
}
DWORD submitTime = GetTickCount
() - submitStartTime;
logger.info
("初始任务提交完成: " + intToString
(submittedTasks
) + " 个任务提交, " +
intToString
(validTasks
) + " 个有效任务, 耗时: " +
intToString
(submitTime
) + "ms", "Analysis"
);
// 检查是否有有效任务
if
(validTasks == 0
) {
logger.warn
("没有有效任务可执行", "Analysis"
);
writeResultsToFile
(resultFile, std::vector<InterferenceResult>
());
DeleteCriticalSection
(&resultCs
);
return 0;
}
// 等待所有初始任务完成
logger.info
("等待初始任务执行完成...", "Analysis"
);
DWORD executionStartTime = GetTickCount
();
try {
pool.waitAll
(3600000
); // 1小时超时
}
catch
(const std::exception& e
) {
logger.error
("初始任务执行超时或异常: " + std::string
(e.what
()), "Analysis"
);
DeleteCriticalSection
(&resultCs
);
return 1;
}
DWORD executionTime = GetTickCount
() - executionStartTime;
logger.info
("初始任务执行完成: " + intToString
(results.size
()) + " 个干涉结果, 耗时: " +
intToString
(executionTime
) + "ms", "Analysis"
);
// 处理失败任务的重试
int retryRound = 1;
const int maxRetryRounds = 3; // 最多重试3轮
while
(failedTaskManager.hasFailedTasks
() && retryRound <= maxRetryRounds
)
{
size_t failedCount = failedTaskManager.getFailedTaskCount
();
logger.info
("开始第 " + intToString
(retryRound
) + " 轮重试, 失败任务数: " + intToString
(failedCount
), "Analysis"
);
int retriedTasks = 0;
FailedTaskManager::FailedTask failedTask;
while
(failedTaskManager.getNextFailedTask
(failedTask
))
{
Task* retryTask = new AnalysisTask
(failedTask.handle1, failedTask.handle2, &results, &resultCs, &failedTaskManager, &logger, failedTask.retryCount
);
pool.addTask
(retryTask
);
retriedTasks++;
if
(retriedTasks % 100 == 0
)
{
logger.debug
("已提交 " + intToString
(retriedTasks
) + "/" + intToString
(failedCount
) + " 个重试任务", "Analysis"
);
}
}
logger.info
("第 " + intToString
(retryRound
) + " 轮重试提交完成: " + intToString
(retriedTasks
) + " 个任务", "Analysis"
);
// 等待重试任务完成
DWORD retryStartTime = GetTickCount
();
try {
pool.waitAll
(1800000
); // 30分钟超时
}
catch
(const std::exception& e
)
{
logger.error
("第 " + intToString
(retryRound
) + " 轮重试执行超时: " + std::string
(e.what
()), "Analysis"
);
break;
}
DWORD retryTime = GetTickCount
() - retryStartTime;
logger.info
("第 " + intToString
(retryRound
) + " 轮重试完成, 耗时: " + intToString
(retryTime
) + "ms, 剩余失败任务: " + intToString
(failedTaskManager.getFailedTaskCount
()), "Analysis"
);
retryRound++;
}
// 最终统计
size_t finalFailedTasks = failedTaskManager.getFailedTaskCount
();
if
(finalFailedTasks > 0
)
{
logger.warn
("分析完成，但仍有 " + intToString
(finalFailedTasks
) +
" 个任务失败并达到最大重试次数", "Analysis"
);
}
else {
logger.info
("所有任务均成功完成", "Analysis"
);
}
// 分析任务执行统计
if
(results.size
() == 0 && validTasks > 0
) {
logger.warn
("所有任务都执行了，但没有发现任何干涉", "Analysis"
);
}
// 写入结果
if
(!writeResultsToFile
(resultFile, results
)) {
logger.error
("写入结果文件失败: " + resultFile, "Analysis"
);
DeleteCriticalSection
(&resultCs
);
return 1;
}
logger.info
("结果写入完成: " + intToString
(results.size
()) + " 个结果 -> " + resultFile, "Analysis"
);
// 清理资源
DeleteCriticalSection
(&resultCs
);
std::cout << "分析进程完成: " << results.size
() << " 个干涉结果" << std::endl;
logger.info
("分析进程正常结束", "Analysis"
);
}
catch
(const std::exception& e
) {
logger.error
("分析进程异常: " + std::string
(e.what
()), "Analysis"
);
std::cerr << "分析进程错误: " << e.what
() << std::endl;
// 记录系统错误信息
DWORD errorCode = GetLastError
();
logger.error
("系统错误码: " + intToString
(errorCode
), "Analysis"
);
return 1;
}
catch
(...
) {
logger.error
("分析进程未知异常", "Analysis"
);
std::cerr << "分析进程未知错误" << std::endl;
return 1;
}
UF_terminate
();
system
("pause"
);
return 0;
}
这是分析进程的程序设计
将这两个程序设计成内存共享模式的设计 并且使用C98编译器标准 返回设计好的完整所有代码
本文详细解析了C语言中的结构体(struct)和联合体(union)的内存分配原则，包括内存对齐和成员变量的空间占用。通过具体实例说明了如何计算不同类型组合的数据结构的大小。
扫一扫
1125
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
