// full code: https://github.com/luoqiangwei/CXX_Simple_Coroutine_Example/blob/main/GuessCoroutine/main.cpp

struct CoRet {
    struct Note {
        int guess;
    };
    struct promise_type {
        int _out;  // 存储co_yield中间结果
        int _res;  // 存储co_return最终结果
        ...
    }
    ...
};

// Guess是一个协程实现
CoRet Guess(CoRet::Note& note) {
    int res = (rand() % 30) + 1;
    CoRet::Input input{ note };
    while (true) {
        int g = co_await input; // 挂起协程，等待调用者更新input信息
        cout << "coroutine: You guess " << g << ", res: " << res << endl;
        int result = res < g ? 1 : (res == g ? 0 : -1);
        co_yield result; // 中断协程执行，并且返回一个值
        if (result == 0) break;
    }
    co_return res;
}

int main(int argc, const char * argv[]) {
    CoRet::Note note = {};
    auto ret = Guess(note);
    while (true) {
        std::cin >> note.guess;
        cout << "main: You input: " << note.guess << endl;
        ret._h.resume(); // 继续执行协程，从co_await恢复运行
        ret._h.resume(); // 继续执行协程，从co_yield恢复运行
        cout << "main: result is " <<
            ((ret._h.promise()._out == 1) ? "larger" :
             ((ret._h.promise()._out == 0) ? "the same" : "smaller")) << endl;
        if (ret._h.promise()._out == 0) break;
    }
    if (ret._h.done()) {
        cout << "main: the result is " << ret._h.promise()._res << endl;
        ret._h.destroy();
    }
    return 0;
}

// 这个接口是协程自身的上下文和逻辑控制，存储一些状态信息（类似于线程的上下文信息，但是线程的对开发者透明）
// Promise接口，指定一系列方法控制协程自身行为。
//      - 协程被调用时的行为
//      - 协程返回时的行为（包含异常时返回的行为）
//      - 自定义co_return或co_yield表达式的对应行为
//        - suspend_never，在co_return或者co_yield运算的时候不停止协程运行
//        - suspend_always，在co_return或者co_yield运算的时候停止协程运行
struct CoRet {
    // 协程的Promise接口必须叫promise_type
    struct promise_type {
        // 存储co_yield产生的中间临时数据值。
        int _out;
        // 存储co_return最终的结果
        int _res;
        // 存储协程中的异常
        std::exception_ptr exception_;
        
        // 初次执行协程体时执行（在初始化协程并执行的时候调用，此函数可用于初始化
        // 用户自定义协程状态信息，同时控制协程是否继续执行）
        //    其他协程或线程再次执行resume恢复协程执行
        suspend_always initial_suspend() { return {}; }
        // 在协程体全部执行结束后执行（即将销毁时调用，此时可以销毁用户自定义协程
        // 状态信息，同时可以暂停协程销毁，让其他协程或线程获取到最终结果）
        //    其他协程或线程再次执行resume恢复协程执行后，销毁
        //
        // 最后必须得suspend，不暂停的话，结构会被销毁，无法拿到最后的返回值
        suspend_always final_suspend() noexcept { return {}; }
        // 协程未捕获异常
        void unhandled_exception() {
            exception_ = std::current_exception();
        }
        // 创建协程时，返回Promise接口实例，给这个外部结构体对应的成员
        CoRet get_return_object() {
            return  {
                coroutine_handle<promise_type>::from_promise(*this)
            };
        }
        // 控制co_yield逻辑
        suspend_never yield_value(int r) {
            _out = r;
            return {};
        }
        // 控制co_return逻辑，用于协程最终return的结果
        void return_value(int r) {
            _res = r;
            cout << "coroutine: set res " << r << endl;
        }
    };
    // 构造时，调用get_return_object赋值，coroutine_handle<promise_type>只能有一个这样的成员,
    // 如果有两个这种类型的成员，会只赋值给结构体中第一个，第二个不会被初始化！
    coroutine_handle<promise_type> _h; // _h.resume(), _h()
};

// Awaitable接口，指定一系列方法控制co_await表达式的语义。
//      当一个值被co_await时，代码会被转换成awaitable对象的一系列方法的调用。
//      - 可以控制是否挂起当前协程。（await_ready，true是不挂起，false是挂起）
//      - 协程恢复时，返回的值（await_resume）
struct CoRet {
    Note& _in;
    // 控制co_await的时候是否暂停并暂时返回，下一次执行时将会继续从暂停位置继续
    // true是不返回，直接执行
    
    // await_ready()在执行co_await表达式求值时先被调用
    // - 返回值表示异步操作是否完成，完成即可继续执行，否则协程被挂起
    //   - 返回true，不会挂起协程，其他两个函数不被执行
    //   - 返回false，表示异步操作未结束，协程被挂起
    bool await_ready() { return false; }
    // await_suspend(coroutine_handle<CoRet::promise_type> h)
    // 在await_ready()返回false的时候被调用
    // - 用于挂起协程，暂停执行，并传递coroutine_handle，用于在异步操作完成，协程
    //   恢复时执行使用。协程状态会被保存，之后从当前点恢复执行
    // - await_suspend()用于设置一些在异步操作完成后，需要检查或清理的资源，例如异步
    //   操作完成的回调函数
    void await_suspend(coroutine_handle<CoRet::promise_type> h) {}
    // await_resume()异步操作完成，并且await_suspend()保存协程状态后被调用
    // - 用于恢复协程执行，并返回异步操作的结果（需要释放await_suspend使用的资源等）
    int await_resume() { return _in.guess; }
};

// full source: https://github.com/luoqiangwei/CXX_Simple_Coroutine_Example/blob/main/GuessCoroutineRunWithSelf/main.cpp

struct CoRet {
    struct promise_type {
        int _out;
        int _res;
        std::exception_ptr exception_;
        suspend_always initial_suspend() { return {}; }
        suspend_always final_suspend() noexcept { return {}; }
        void unhandled_exception() {
            exception_ = std::current_exception();
        }
        CoRet get_return_object() {
            return  {
                coroutine_handle<promise_type>::from_promise(*this)
            };
        }
        suspend_never yield_value(int r) {
            _out = r;
            return {};
        }
        void return_value(int r) {
            _res = r;
            cout << "coroutine: set res " << r << endl;
        }
    };
    
    struct Note {
        int guess;
    };
    
    struct Input {
        Note& _in;
        
        bool await_ready() { return false; }
        void await_suspend(coroutine_handle<CoRet::promise_type> h) {
            // 更好的做法，是将耗时任务在co_await的时候扔到线程池里，然后这个co_await的调用者线程可以继续做别的事情
            // 但是这里还有一个问题，如果在协程调度器里把这个任务submit给线程池了，那么线程池完成任务后如何还给原来的线程调度器呢
            std::thread([this, h]() {
                std::cin >> _in.guess;
                cout << "suspend finish: You input: " << _in.guess << endl;
                h.resume();
            }).detach(); // detach是为了让线程可以活着离开作用域，否则触发ABORT
        }
        int await_resume() { return _in.guess; }
    };

    coroutine_handle<promise_type> _h;
    
};


// Guess是一个协程实现
CoRet Guess() {
    int res = (rand() % 30) + 1;
    CoRet::Note note = {};
    CoRet::Input input{ note };
    cout << "coroutine: Init Finish" << endl;
    while (true) {
        int g = co_await input;
        cout << "coroutine: You guess " << g << ", res: " << res << endl;
        int result = res < g ? 1 : (res == g ? 0 : -1);
        cout << "coroutine: result is " <<
            ((result == 1) ? "larger" :
             ((result == 0) ? "the same" : "smaller")) << endl;
        if (result == 0) {
            break;
        }
    }

    cout << "coroutine: the game is finish" << endl;
    co_return res;
}

int main(int argc, const char * argv[]) {
    srand((uint)time(nullptr));
    auto coroutine = Guess();
    cout << "main: make a guess ..." << endl;
    // Start coroutine...
    coroutine._h.resume();
    int count = 0;
    while (true) {
        if (coroutine._h.done()) {
            cout << "main: the coroutine result is " << coroutine._h.promise()._res << endl;
            coroutine._h.destroy();
            break;
        }
        count += 5;
        sleep(5);
        cout << "main: sleep wait coroutine " << count << " s" << endl;
    }
    return 0;
}

int copy(Stream streamR, Stream streamW) {
    char buf[512];
    int cnt = 0;
    int total = 0;
    do {
        cnt = streamR.read(sizeof(buf), buf);
        if (cnt == 0) break;
        cnt = streamW.write(cnt, buf);
        total += count;
    } while (cnt > 0);
    return total;
}

future<int> copy(Stream streamR, Stream streamW) {
    char buf[512];
    int cnt = 0;
    int total = 0;
    do {
        cnt = co_await streamR.read(sizeof(buf), buf);
        if (cnt == 0) break;
        cnt = co_await streamW.write(cnt, buf);
        total += count;
    } while (cnt > 0);
    co_return total;
}

void fetch_user_data(std::function<void(std::string)> callback) {
    // 模拟异步操作
    std::thread([callback]() {
        std::this_thread::sleep_for(std::chrono::seconds(1));
        callback("user123");
    }).detach();
}

void fetch_user_permissions(const std::string& user, std::function<void(std::string)> callback) {
    std::thread([callback]() {
        std::this_thread::sleep_for(std::chrono::seconds(1));
        callback("admin");
    }).detach();
}

void process_permissions(const std::string& permissions) {
    std::cout << "Processing permissions: " << permissions << std::endl;
}

// 嵌套回调实现
void perform_task() {
    fetch_user_data([](const std::string& user) {
        fetch_user_permissions(user, [](const std::string& permissions) {
            process_permissions(permissions);
        });
    });
}

std::future<std::string> fetch_user_data() {
    return std::async(std::launch::async, []() -> std::string {
        std::this_thread::sleep_for(std::chrono::seconds(1));
        return "user123";
    });
}

std::future<std::string> fetch_user_permissions(const std::string& user) {
    return std::async(std::launch::async, [user]() -> std::string {
        std::this_thread::sleep_for(std::chrono::seconds(1));
        return "admin";
    });
}

void process_permissions(const std::string& permissions) {
    std::cout << "Processing permissions: " << permissions << std::endl;
}

// 协程实现任务
std::future<void> perform_task() {
    co_await std::async(std::launch::async, []() {});
    auto user = co_await fetch_user_data();
    auto permissions = co_await fetch_user_permissions(user);
    process_permissions(permissions);
}

int main() {
    void* co_hdl = f();
    co_hdl.resume();
    co_hdl.resume();
    co_hdl.destory();
    return 0;
}

struct {
  void (*__r)(); // function pointer to the `resume` function
  void (*__d)(); // function pointer to the `destroy` function
  promise_type; // the corresponding `promise_type`
  ... // Any other needed information
}

struct CoroutineFrame {
    int suspend_point_index; // 当前挂起点索引
    ... // 持久化的局部变量
};

void ramp_function(CoroutineFrame* frame, ...args) {
    frame->suspend_point_index = 0;
    // 协程的初始化逻辑
    if (/* 挂起条件 */) {
        frame->suspend_point_index = 1;
        return; // 挂起
    }
    // 后续代码
}

void resume_function(CoroutineFrame* frame) {
    switch (frame->suspend_point_index) {
        case 0:
            ramp_function(frame); // 恢复到初始点
            break;
        case 1:
            // 从挂起点 1 恢复
            break;
        ...
    }
}

void destroy_function(CoroutineFrame* frame) {
    // 清理资源
    delete frame;
}

CoroutineFrame* frame = new CoroutineFrame();
ramp_function(frame, ...args); // 调用 ramp function
resume_function(frame);        // 恢复执行
destroy_function(frame);       // 销毁协程

struct Continuation {
    void* function_pointer; // 下一步的函数指针
    ... // 持久化的局部变量
};

Continuation* ramp_function(...args) {
    Continuation* cont = allocate_continuation();
    cont->function_pointer = suspend_point_1;
    return cont;
}

Continuation* suspend_point_1(Continuation* cont) {
    // 恢复挂起点 1 的逻辑
    if (/* 挂起条件 */) {
        cont->function_pointer = suspend_point_2;
        return cont; // 返回下一个 continuation
    }
    return nullptr; // 协程结束
}

Continuation* suspend_point_2(Continuation* cont) {
    // 恢复挂起点 2 的逻辑
    return nullptr; // 协程结束
}

Continuation* cont = ramp_function(...args);
while (cont) {
    cont = ((ContinuationFunction)cont->function_pointer)(cont);
}

struct async_context {
    struct async_context *caller_context;
    ...
}

char *context_projection_function(struct async_context *callee_ctxt) {
    return callee_ctxt->caller_context;
}

%resume_func_ptr = call ptr @llvm.coro.async.resume()

call {ptr, ptr, ptr} @llvm.coro.id.async(
    ptr %async.ctxt, 
    uint32_t %context_size, 
    uint32_t %alignment)

struct async_function_pointer {
    uint32_t relative_function_pointer_to_async_impl;
    uint32_t context_size;
};

struct AsyncContext {
    AsyncContext* caller_context; // 调用者上下文
    ... // 异步调用链的数据
};

struct CoroutineFrame {
    AsyncContext* context;
    ... // 协程帧的持久化数据
};

void ramp_function(AsyncContext* context, ...args) {
    CoroutineFrame* frame = new CoroutineFrame();
    frame->context = context;
    // 协程的初始化逻辑
    if (/* 挂起条件 */) {
        // 保存挂起点
        context->caller_context = get_current_async_context();
        suspend_function(async_resume_function, frame);
        return;
    }
    // 协程完成
}

void async_resume_function(AsyncContext* context) {
    CoroutineFrame* frame = get_frame_from_context(context);
    // 恢复协程逻辑
}

void suspend_function(void (*resume_func)(AsyncContext*), CoroutineFrame* frame) {
    // 保存 resume 函数，并进入异步挂起
    save_async_context(resume_func, frame->context);
}

AsyncContext* root_context = create_async_context();
ramp_function(root_context, ...args); // 触发协程

# 查看CPU最大频率
cat /sys/devices/system/cpu/cpu7/cpufreq/scaling_available_frequencies
# 4089600Hz根本无法提上去，3014400Hz总是会回落到2784000Hz（反复横跳），
# 所以最后用2784000Hz来测试！
echo 2784000> /sys/devices/system/cpu/cpu7/cpufreq/scaling_max_freq
echo 2784000> /sys/devices/system/cpu/cpu7/cpufreq/scaling_min_freq
# 2784000Hz就稳定了 😓
cat /sys/devices/system/cpu/cpu7/cpufreq/scaling_cur_freq
# 运行大概5分钟就可以Ctrl + C了
CPU_AFFINITY=7 simpleperf stat ./测试程序

int main() {
    unsigned long long res = 0;
    unsigned long long sum = 0;

    for (unsigned long long i = 0; i < 10000000000000000ULL; i++) {
        res = i;
        sum += res;
        asm volatile("nop");
    }

    return (int)(res + sum);
}

Performance counter statistics:

#             count  event_name                # count / runtime
      # 总共的CPU时钟周期
    902,484,444,032  cpu-cycles                # 2.782264 GHz
      # 前端（取指+译码）有多少周期空闲：2.356%
      2,126,629,380  stalled-cycles-frontend   # 6.556 M/sec
      # 后端（执行+写回）有多少周期空闲：3.037%
      2,740,797,017  stalled-cycles-backend    # 8.450 M/sec
      # CPU执行的指令总数
  2,693,398,982,520  instructions              # 8.303 G/sec
      # CPU执行的分支指令数目（遇到条件跳转时触发）：33.312%
    897,225,753,075  branch-instructions       # 2.766 G/sec
      # CPU执行分支指令预测失败次数（遇到条件跳转时触发）：0.0000006159%
          1,658,970  branch-misses             # 5.114 K/sec
      # 测量的总时间
  324370.759684(ms)  task-clock                # 0.999991 cpus used
      # 上下文切换次数
                 18  context-switches          # 0.055 /sec
      # 缺页次数
                246  page-faults               # 0.758 /sec

int main() {
    unsigned long long res = 0;
    unsigned long long sum = 0;

    #pragma unroll
    for (unsigned long long i = 0; i < 10000000000000000ULL; i++) {
        res = i;
        sum += res;
        asm volatile("nop");
    }

    return (int)(res + sum);
}

Performance counter statistics:

#             count  event_name                # count / runtime
    985,449,462,578  cpu-cycles                # 2.782279 GHz
      2,176,472,797  stalled-cycles-frontend   # 6.145 M/sec
      3,043,795,245  stalled-cycles-backend    # 8.594 M/sec
  7,838,421,723,115  instructions              # 22.131 G/sec
    # 条件跳转指令的占比：10.0000%
    783,852,286,826  branch-instructions       # 2.213 G/sec
          1,417,902  branch-misses             # 4.003 K/sec
  354187.916498(ms)  task-clock                # 0.999999 cpus used
                  5  context-switches          # 0.014 /sec
                238  page-faults               # 0.672 /sec

int main() {
    unsigned long long res = 0;
    unsigned long long sum = 0;

    #pragma unroll
    for (unsigned long long i = 0; i < 10000000000000000ULL; i++) {
        res = i;
        sum *= res;
        asm volatile("nop");
    }

    return (int)(res + sum);
}

Performance counter statistics:

#             count  event_name                # count / runtime
    498,646,336,876  cpu-cycles                # 2.782260 GHz
      1,107,763,386  stalled-cycles-frontend   # 6.181 M/sec
      1,497,657,830  stalled-cycles-backend    # 8.356 M/sec
  3,966,417,253,814  instructions              # 22.131 G/sec
    # 条件跳转指令的占比：10.0000%
    396,646,880,276  branch-instructions       # 2.213 G/sec
            743,042  branch-misses             # 4.146 K/sec
  179223.487370(ms)  task-clock                # 0.999997 cpus used
                 13  context-switches          # 0.073 /sec
                229  page-faults               # 1.278 /sec

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// 函数用于执行 objdump 并获取汇编代码
char* get_disassembly(const char* binary_path) {
    // 打开临时文件
    FILE* tmp_file = tmpfile();
    if (!tmp_file) {
        perror("Failed to open temporary file");
        exit(EXIT_FAILURE);
    }

    // 执行 objdump 并将输出重定向到临时文件
    char command[256];
    snprintf(command, sizeof(command), "objdump -d %s > %p", binary_path, tmp_file);
    if (system(command) != 0) {
        perror("Failed to execute objdump");
        exit(EXIT_FAILURE);
    }

    // 重新定位临时文件的文件指针到开始
    rewind(tmp_file);

    // 读取临时文件内容到缓冲区
    fseek(tmp_file, 0, SEEK_END);
    long size = ftell(tmp_file);
    fseek(tmp_file, 0, SEEK_SET);
    char* disassembly = (char*)malloc(size + 1);
    fread(disassembly, 1, size, tmp_file);
    disassembly[size] = '\0';

    // 关闭临时文件
    fclose(tmp_file);

    return disassembly;
}

// 简单的字符串匹配函数，用于查找特定类型的指令
int count_instructions(char* disassembly, const char* instruction_type) {
    int count = 0;
    char* pos = disassembly;
    char* result = NULL;

    // 使用 strstr 来查找指令
    while ((result = strstr(pos, instruction_type)) != NULL) {
        count++;
        pos = result + 1; // 移动到找到的指令之后，继续搜索
    }

    return count;
}

// 函数用于计算所有指令的总数
int count_all_instructions(char* disassembly) {
    int count = 0;
    char* line = strtok(disassembly, "\n");
    while (line) {
        count++;
        line = strtok(NULL, "\n");
    }
    return count;
}

int main(int argc, char* argv[]) {
    if (argc != 2) {
        printf("Usage: %s <binary_path>\n", argv[0]);
        return EXIT_FAILURE;
    }

    const char* binary_path = argv[1];
    char* disassembly = get_disassembly(binary_path);

    int jumps = count_instructions(disassembly, "jmp");
    jumps += count_instructions(disassembly, "jcc");
    int calls = count_instructions(disassembly, "call");
    int rets = count_instructions(disassembly, "ret");
    int movs = count_instructions(disassembly, "mov");
    int adds = count_instructions(disassembly, "add");
    int subs = count_instructions(disassembly, "sub");
    int all_instructions = count_all_instructions(disassembly);

    printf("Jumps: %d\n", jumps);
    printf("Calls: %d\n", calls);
    printf("Returns: %d\n", rets);
    printf("Movs: %d\n", movs);
    printf("Adds: %d\n", adds);
    printf("Subs: %d\n", subs);
    printf("All Instructions: %d\n", all_instructions);

    free(disassembly);
    return EXIT_SUCCESS;
}