process_monitor: C++ 交互式进程监控，让科学计算可控可停

#include "process_monitor.h"

class MyCalculator : public utilsxx::process_monitor {
public:
    void process() override {
        while (!end_process()) {
            // 你的计算逻辑...
            do_calculation_step();
            
            // 每秒钟检查一次键盘输入
            wait_for_keyboard(1);
        }
    }
};

int main() {
    MyCalculator calc;
    calc.start_monitoring();
    return 0;
}

// 进入非阻塞模式（键盘监控时）
tio.c_lflag &= ~(ICANON | ECHO);  // 关闭规范模式和回显
tio.c_cc[VMIN] = 0;               // 最小字符数为0
tio.c_cc[VTIME] = 0;              // 无超时

// 恢复规范模式（确认对话框时）
tio.c_lflag |= (ICANON | ECHO);   // 开启规范模式和回显

struct MonitorConfig {
    char pause_key = 'p';           // 暂停键
    char quit_key = 'q';            // 退出键
    char status_key = 's';          // 状态键
    char continue_key = 'c';        // 继续键
    bool show_status_on_pause = true;  // 暂停时自动显示状态
    int check_interval_ms = 100;    // 键盘检查间隔（毫秒）
};

class MyCalculator : public utilsxx::process_monitor {
public:
    MyCalculator() : process_monitor(MonitorConfig{
        ' ',   // 空格键暂停
        'q',   // q 键退出
        'i',   // i 键显示信息
        'r',   // r 键继续（resume）
        true,  // 暂停时显示状态
        50     // 50ms 检查间隔（更灵敏）
    }) {}
    
    void process() override { /* ... */ }
};

#include "process_monitor.h"
#include <cmath>
#include <random>
#include <iomanip>
#include <sstream>

using namespace utilsxx;

class MonteCarloPiCalculator : public process_monitor {
private:
    int total_points_;
    int points_in_circle_;
    double current_pi_estimate_;
    
public:
    MonteCarloPiCalculator() : process_monitor(MonitorConfig{
        ' ',  // 空格键暂停
        'q',  // q键退出
        'i',  // i键显示信息
        'c',  // c键继续
        true, // 暂停时显示状态
        50    // 50ms检查间隔
    }), total_points_(0), points_in_circle_(0), current_pi_estimate_(0.0) {}
    
    void process() override {
        std::random_device rd;
        std::mt19937 gen(rd());
        std::uniform_real_distribution<> dis(-1.0, 1.0);
        
        std::cout << "Starting Monte Carlo π calculation..." << std::endl;
        std::cout << "Press SPACE to pause, 'i' for info, 'q' to quit." << std::endl;
        
        while (!end_process()) {
            // 生成随机点
            double x = dis(gen);
            double y = dis(gen);
            
            // 检查点是否在单位圆内
            if (x*x + y*y <= 1.0) {
                points_in_circle_++;
            }
            total_points_++;
            
            // 计算π的估计值
            current_pi_estimate_ = 4.0 * points_in_circle_ / total_points_;
            
            // 每1000次迭代更新状态信息
            if (total_points_ % 1000 == 0) {
                std::stringstream ss;
                ss << "π ≈ " << std::fixed << std::setprecision(8) << current_pi_estimate_ 
                   << " (error: " << std::abs(current_pi_estimate_ - M_PI) << ")";
                set_status_info(ss.str());
            }
            
            // 更新迭代计数
            increment_iteration();
            
            // 模拟计算延迟
            std::this_thread::sleep_for(std::chrono::milliseconds(1));
        }
        
        std::cout << "\nFinal result after " << total_points_ << " iterations:" << std::endl;
        std::cout << "π ≈ " << std::fixed << std::setprecision(10) << current_pi_estimate_ << std::endl;
    }
    
    // 重写状态显示：展示计算细节
    void show_status() override {
        process_monitor::show_status();  // 调用基类显示基本状态
        
        std::cout << "Calculation Details:" << std::endl;
        std::cout << "  Total points: " << total_points_ << std::endl;
        std::cout << "  Points in circle: " << points_in_circle_ << std::endl;
        std::cout << "  Current π estimate: " << std::fixed << std::setprecision(8) 
                  << current_pi_estimate_ << std::endl;
        std::cout << "  Actual π value: " << M_PI << std::endl;
        std::cout << "  Accuracy: " << std::fixed << std::setprecision(2) 
                  << (1.0 - std::abs(current_pi_estimate_ - M_PI) / M_PI) * 100.0 << "%" << std::endl;
    }
    
    // 重写暂停回调
    void on_pause() override {
        process_monitor::on_pause();
        std::cout << "\nCalculation paused at iteration " << get_iteration_count() << std::endl;
        std::cout << "Current π estimate: " << current_pi_estimate_ << std::endl;
    }
    
    // 重写恢复回调
    void on_resume() override {
        process_monitor::on_resume();
        std::cout << "\nResuming calculation from iteration " << get_iteration_count() << std::endl;
    }
};

int main() {
    MonteCarloPiCalculator calculator;
    calculator.start_monitoring();
    return 0;
}

void on_pause() override {
    process_monitor::on_pause();
    
    // 保存当前计算状态到文件
    std::ofstream checkpoint("checkpoint.dat");
    checkpoint << iteration << " " << current_result << std::endl;
    checkpoint.close();
    
    std::cout << "Checkpoint saved." << std::endl;
}

void on_resume() override {
    // 可选：从检查点恢复
    process_monitor::on_resume();
}

void process() override {
    while (!end_process()) {
        // 根据当前状态调整步长
        if (get_state() == ProcessState::RUNNING) {
            step_size = adaptive_step_size();
        }
        
        compute_step(step_size);
        increment_iteration();
        wait_for_keyboard(1);
    }
}

void process() override {
    // 阶段1：预处理
    std::cout << "Phase 1: Preprocessing..." << std::endl;
    for (int i = 0; i < 100 && !end_process(); i++) {
        preprocess_step(i);
        increment_iteration();
        wait_for_keyboard(1);
    }
    
    // 阶段2：主计算
    std::cout << "Phase 2: Main computation..." << std::endl;
    set_status_info("Entering main computation phase");
    while (!end_process() && !converged()) {
        compute_step();
        increment_iteration();
        wait_for_keyboard(1);
    }
    
    // 阶段3：后处理
    std::cout << "Phase 3: Post-processing..." << std::endl;
    // ...
}

#include "process_monitor.h"
#include "progress_bar.hpp"

class MonitoredTask : public utilsxx::process_monitor {
    utilsxx::progress_bar bar_;
    
public:
    void process() override {
        bar_.hide_cursor();
        bar_.reset("Computing", 1000);
        
        for (int i = 0; i < 1000 && !end_process(); i++) {
            bar_.tick();
            do_work();
            increment_iteration();
            wait_for_keyboard(1);
        }
        
        bar_.show_cursor();
    }
};

reset
# 或
stty sane

./my_program > results.log   # 计算结果写入文件，键盘交互仍在终端