#include <stdio.h>
#include <stdlib.h>
#include <kupl/kupl_graph.h>  // KUPL计算图核心头文件
#include <pthread.h>         // 线程库头文件

// 定义数据结构：存储乘法计算的输入输出数据（适配E = A*B + C*D的计算逻辑）
typedef struct {
    float* A_data;  // 输入数据A
    float* B_data;  // 输入数据B
    float* F_data;  // 输出数据F（F = A*B 或 F = C*D）
} data_axb_t;

// 定义数据结构：存储加法计算的输入输出数据
typedef struct {
    float* F1_data; // 输入数据F1（A*B的结果）
    float* F2_data; // 输入数据F2（C*D的结果）
    float* E_data;  // 输出数据E（E = F1 + F2）
} data_add_t;

// 乘法计算函数（绑定到计算节点1、节点2）
static void fun_axb(void *args) {
    if (args == NULL) {  // 错误处理：避免空指针异常
        printf("Error: fun_axb args is NULL\n");
        return;
    }
    data_axb_t *data = (data_axb_t *)args;
    // 执行乘法计算：F = A * B
    (*data->F_data) = (*data->A_data) * (*data->B_data);
    printf("Multiplication task completed: %.2f * %.2f = %.2f\n", 
           *data->A_data, *data->B_data, *data->F_data);
}

// 加法计算函数（绑定到计算节点3）
static void fun_add(void *args) {
    if (args == NULL) {  // 错误处理：避免空指针异常
        printf("Error: fun_add args is NULL\n");
        return;
    }
    data_add_t *data = (data_add_t *)args;
    // 执行加法计算：E = F1 + F2
    (*data->E_data) = (*data->F1_data) + (*data->F2_data);
    printf("Addition task completed: %.2f + %.2f = %.2f\n", 
           *data->F1_data, *data->F2_data, *data->E_data);
}

// 结果输出函数（绑定到计算节点4）
static void fun_output(void *args) {
    if (args == NULL) {
        printf("Error: fun_output args is NULL\n");
        return;
    }
    float* E_data = (float*)args;
    // 输出最终计算结果
    printf("Final calculation result: E = %.2f\n", *E_data);
}

int main() {
    // 1. 初始化输入输出数据（模拟实际计算数据）
    float A = 3.5f, B = 2.0f, C = 4.5f, D = 3.0f;  // 输入数据
    float F1 = 0.0f, F2 = 0.0f, E = 0.0f;          // 中间结果和最终结果

    // 2. 初始化数据结构，绑定输入输出数据
    data_axb_t data1 = {&A, &B, &F1};  // 节点1的数据（计算A*B=F1）
    data_axb_t data2 = {&C, &D, &F2};  // 节点2的数据（计算C*D=F2）
    data_add_t data3 = {&F1, &F2, &E}; // 节点3的数据（计算F1+F2=E）

    // 3. 创建静态图（DAG），指定静态图配置（默认配置，适配鲲鹏架构）
    kupl_sgraph_t* sgraph = kupl_sgraph_create(NULL);
    if (sgraph == NULL) {  // 错误处理：静态图创建失败
        printf("Error: Failed to create static graph\n");
        return -1;
    }

    // 4. 配置节点描述符，添加4个计算节点到静态图
    // 节点1：执行A*B乘法计算
    kupl_sgraph_node_desc_t node1_desc = {
        .func = fun_axb,    // 绑定乘法计算函数
        .args = &data1,     // 绑定节点数据
        .name = "node1_axb" // 节点名称（用于调试）
    };
    kupl_sgraph_node_t* node1 = kupl_sgraph_add_node(sgraph, &node1_desc);
    if (node1 == NULL) {
        printf("Error: Failed to add node1\n");
        kupl_sgraph_destroy(sgraph);
        return -1;
    }

    // 节点2：执行C*D乘法计算
    kupl_sgraph_node_desc_t node2_desc = {
        .func = fun_axb,
        .args = &data2,
        .name = "node2_axb"
    };
    kupl_sgraph_node_t* node2 = kupl_sgraph_add_node(sgraph, &node2_desc);
    if (node2 == NULL) {
        printf("Error: Failed to add node2\n");
        kupl_sgraph_destroy(sgraph);
        return -1;
    }

    // 节点3：执行F1+F2加法计算
    kupl_sgraph_node_desc_t node3_desc = {
        .func = fun_add,
        .args = &data3,
        .name = "node3_add"
    };
    kupl_sgraph_node_t* node3 = kupl_sgraph_add_node(sgraph, &node3_desc);
    if (node3 == NULL) {
        printf("Error: Failed to add node3\n");
        kupl_sgraph_destroy(sgraph);
        return -1;
    }

    // 节点4：输出最终结果E
    kupl_sgraph_node_desc_t node4_desc = {
        .func = fun_output,
        .args = &E,
        .name = "node4_output"
    };
    kupl_sgraph_node_t* node4 = kupl_sgraph_add_node(sgraph, &node4_desc);
    if (node4 == NULL) {
        printf("Error: Failed to add node4\n");
        kupl_sgraph_destroy(sgraph);
        return -1;
    }

    // 5. 定义节点间的依赖关系，构建DAG有向无环图
    // 依赖1：node1执行完成后，才能执行node3（F1是node3的输入）
    if (kupl_sgraph_add_dep(node1, node3) != KUPL_SUCCESS) {
        printf("Error: Failed to add dependency node1 -> node3\n");
        kupl_sgraph_destroy(sgraph);
        return -1;
    }
    // 依赖2：node2执行完成后，才能执行node3（F2是node3的输入）
    if (kupl_sgraph_add_dep(node2, node3) != KUPL_SUCCESS) {
        printf("Error: Failed to add dependency node2 -> node3\n");
        kupl_sgraph_destroy(sgraph);
        return -1;
    }
    // 依赖3：node3执行完成后，才能执行node4（E是node4的输入）
    if (kupl_sgraph_add_dep(node3, node4) != KUPL_SUCCESS) {
        printf("Error: Failed to add dependency node3 -> node4\n");
        kupl_sgraph_destroy(sgraph);
        return -1;
    }

    // 6. 创建动态图，启用鲲鹏服务器所有CPU核心（KUPL_ALL_EXECUTORS）
    kupl_graph_t* graph = kupl_graph_create(KUPL_ALL_EXECUTORS, NULL);
    if (graph == NULL) {
        printf("Error: Failed to create dynamic graph\n");
        kupl_sgraph_destroy(sgraph);
        return -1;
    }

    // 7. 将静态图封装为任务，提交至动态图执行
    kupl_sgraph_desc_t sgraph_desc = {.sgraph = sgraph};
    kupl_task_info_t task_info = {
        .type = KUPL_TASK_TYPE_SGRAPH,  // 任务类型：静态图任务
        .desc = &sgraph_desc            // 绑定静态图描述符
    };
    if (kupl_graph_submit(graph, &task_info) != KUPL_SUCCESS) {
        printf("Error: Failed to submit task to dynamic graph\n");
        kupl_graph_destroy(graph);
        kupl_sgraph_destroy(sgraph);
        return -1;
    }

    // 8. 阻塞等待所有任务执行完成（等待node4输出结果后，再继续执行）
    printf("Waiting for all tasks to complete...\n");
    kupl_graph_wait(graph);

    // 9. 销毁静态图、动态图，释放资源（避免内存泄漏）
    kupl_graph_destroy(graph);
    kupl_sgraph_destroy(sgraph);

    // 10. 验证计算结果（手动计算：E = 3.5*2.0 + 4.5*3.0 = 7.0 + 13.5 = 20.5）
    float expected_E = A*B + C*D;
    if (abs(E - expected_E) < 1e-6) {  // 浮点数比较，允许微小误差
        printf("Experiment succeeded: Calculation result is correct!\n");
    } else {
        printf("Experiment failed: Calculation result is incorrect!\n");
        printf("Expected E = %.2f, Actual E = %.2f\n", expected_E, E);
        return -1;
    }

    return 0;
}

#include <kupl/kupl_graph.h>  // 必须引入KUPL计算图头文件，否则无法调用核心接口

// 1. 数据结构定义（核心：绑定输入输出数据，适配计算逻辑）
typedef struct {
    float* A_data;  // 输入数据指针，指向外部定义的变量A
    float* B_data;  // 输入数据指针，指向外部定义的变量B
    float* F_data;  // 输出数据指针，指向中间结果F
} data_axb_t;

// 2. 计算函数定义（核心：封装计算逻辑，将函数绑定到节点）
static void fun_axb(void *args) {
    if (args == NULL) {  // 错误处理：鲲鹏平台对内存访问要求严格，避免空指针异常
        printf("Error: fun_axb args is NULL\n");
        return;
    }
    data_axb_t *data = (data_axb_t *)args;  // 类型转换，获取节点绑定的数据
    (*data->F_data) = (*data->A_data) * (*data->B_data);  // 核心计算逻辑
}

// 3. 静态图创建（核心接口：kupl_sgraph_create）
kupl_sgraph_t* sgraph = kupl_sgraph_create(NULL);
// 解析：
// - 函数原型：kupl_sgraph_t* kupl_sgraph_create(const kupl_sgraph_attr_t* attr);
// - 参数attr：静态图配置属性，传入NULL表示使用默认配置（适配鲲鹏架构，节点最大数量、缓存大小自动调整）；
// - 返回值：静态图实例指针，若为NULL，说明静态图创建失败（如内存不足）；
// - 鲲鹏适配：该接口底层会申请鲲鹏服务器的内存资源，优先使用L3缓存，提升数据访问效率。

// 4. 节点描述符配置（核心：绑定函数、数据、节点名称）
kupl_sgraph_node_desc_t node1_desc = {
    .func = fun_axb,    // 绑定计算函数（fun_axb为乘法计算逻辑）
    .args = &data1,     // 绑定数据结构实例（data1存储A、B、F1的指针）
    .name = "node1_axb" // 节点名称，用于调试（可通过KUPL工具查看节点执行状态）
};
// 解析：节点描述符是连接计算逻辑和静态图的桥梁，KUPL通过该描述符，将计算函数和数据绑定到节点，
// 动态图调度时，会自动调用节点绑定的函数，并传入绑定的数据，实现任务的自动化执行。

// 5. 添加节点到静态图（核心接口：kupl_sgraph_add_node）
kupl_sgraph_node_t* node1 = kupl_sgraph_add_node(sgraph, &node1_desc);
// 解析：
// - 函数原型：kupl_sgraph_node_t* kupl_sgraph_add_node(kupl_sgraph_t* sgraph, const kupl_sgraph_node_desc_t* desc);
// - 参数sgraph：静态图实例指针，指定节点要添加到的静态图；
// - 参数desc：节点描述符指针，指定节点的配置信息；
// - 返回值：节点实例指针，若为NULL，说明节点添加失败（如静态图实例无效）；
// - 鲲鹏适配：添加节点时，KUPL会自动为节点分配鲲鹏服务器的内存资源，优化数据存储位置，适配多级内存架构。

// 核心接口：kupl_sgraph_add_dep（添加节点间的依赖关系）
kupl_sgraph_add_dep(node1, node3);  // node1执行完成后，才能执行node3
kupl_sgraph_add_dep(node2, node3);  // node2执行完成后，才能执行node3
kupl_sgraph_add_dep(node3, node4);  // node3执行完成后，才能执行node4

// 解析：
// 1. 函数原型：kupl_status_t kupl_sgraph_add_dep(kupl_sgraph_node_t* prev_node, kupl_sgraph_node_t* next_node);
// 2. 参数说明：
//    - prev_node：前置节点（依赖节点），即必须先执行完成的节点（如node1、node2）；
//    - next_node：后置节点（被依赖节点），即需要等待前置节点执行完成才能执行的节点（如node3、node4）；
// 3. 返回值：KUPL_SUCCESS表示依赖关系添加成功，其他值表示失败（如节点无效、存在循环依赖）；
// 4. 依赖关系逻辑（对应E = A*B + C*D）：
//    - node1（A*B）和node2（C*D）无前置依赖，可并行执行（动态图会分配两个线程，同时执行这两个节点）；
//    - node3（F1+F2）的前置依赖是node1和node2，必须等待两个乘法任务都完成，才能执行加法运算；
//    - node4（输出E）的前置依赖是node3，必须等待加法任务完成，才能输出最终结果；
// 5. 鲲鹏适配：该接口底层会构建依赖关系表，动态图调度时，会根据鲲鹏CPU核心的负载情况，
//    调度前置节点并行执行，充分利用多核算力，同时确保数据的正确性，避免数据竞争。

// 补充：依赖关系校验（避免循环依赖）
// 若添加如下依赖，会返回失败（node3依赖node4，node4依赖node3，形成循环）：
// kupl_sgraph_add_dep(node3, node4);
// kupl_sgraph_add_dep(node4, node3);
// 循环依赖会导致DAG图无效，静态图无法提交至动态图执行，KUPL会自动检测并返回错误。

#include <kupl/kupl_graph.h>

// 1. 创建动态图（核心接口：kupl_graph_create）
kupl_graph_t* graph = kupl_graph_create(KUPL_ALL_EXECUTORS, NULL);
// 解析：
// - 函数原型：kupl_graph_t* kupl_graph_create(kupl_executor_mask_t executor_mask, const kupl_graph_attr_t* attr);
// - 参数executor_mask：执行器掩码，指定动态图可使用的CPU核心；
//   - KUPL_ALL_EXECUTORS：启用鲲鹏服务器的所有CPU核心（本次实验为96核），最大化利用多核并行算力；
//   - 也可指定特定核心（如KUPL_EXECUTOR_MASK(0,1)，仅使用第0、1核心）；
// - 参数attr：动态图配置属性，传入NULL表示使用默认配置（负载均衡调度策略）；
// - 返回值：动态图实例指针，若为NULL，说明动态图创建失败；
// - 鲲鹏适配：动态图创建时，会自动识别鲲鹏920服务器的核心数量，初始化线程池，线程数量与核心数量匹配，
//   避免线程过多导致的上下文切换开销，适配鲲鹏多核架构的调度需求。

// 2. 封装静态图为任务，提交至动态图（核心接口：kupl_graph_submit）
kupl_sgraph_desc_t sgraph_desc = {.sgraph = sgraph};  // 静态图描述符，绑定静态图实例
kupl_task_info_t task_info = {
    .type = KUPL_TASK_TYPE_SGRAPH,  // 任务类型：静态图任务（KUPL支持多种任务类型）
    .desc = &sgraph_desc            // 任务描述符，绑定静态图描述符
};
kupl_graph_submit(graph, &task_info);  // 提交任务至动态图
// 解析：
// - 函数原型：kupl_status_t kupl_graph_submit(kupl_graph_t* graph, const kupl_task_info_t* task_info);
// - 参数graph：动态图实例指针；
// - 参数task_info：任务信息，指定任务类型和任务描述符；
// - 返回值：KUPL_SUCCESS表示任务提交成功；
// - 提交后，动态图会立即解析静态图的DAG结构，调度节点并行执行，无需手动干预，
//   动态图会根据核心负载情况，分配线程执行节点任务（如node1、node2分配两个独立线程）。

// 3. 阻塞等待任务执行完成（核心接口：kupl_graph_wait）
kupl_graph_wait(graph);
// 解析：
// - 函数原型：kupl_status_t kupl_graph_wait(kupl_graph_t* graph);
// - 作用：阻塞当前主线程，等待动态图中所有任务（静态图的所有节点）执行完成，
//   确保主线程不会提前退出，导致任务未执行完成；
// - 鲲鹏适配：该接口底层会等待所有线程池中的线程执行完成，获取每个节点的执行状态，
//   确保任务执行的完整性，适配高性能计算中对任务执行可靠性的要求。

// 4. 资源释放（核心接口：kupl_graph_destroy、kupl_sgraph_destroy）
kupl_graph_destroy(graph);    // 销毁动态图，释放线程池、动态图占用的内存资源
kupl_sgraph_destroy(sgraph);  // 销毁静态图，释放节点、依赖关系占用的内存资源
// 解析：
// - 函数原型：void kupl_graph_destroy(kupl_graph_t* graph);
//              void kupl_sgraph_destroy(kupl_sgraph_t* sgraph);
// - 作用：手动销毁动态图和静态图实例，释放占用的内存、线程等资源，避免内存泄漏；
// - 注意事项：必须先销毁动态图，再销毁静态图（动态图依赖静态图实例），
//   否则会导致内存错误，这是鲲鹏高性能编程中资源管理的重要规范，
//   因为鲲鹏服务器的内存资源宝贵，内存泄漏会严重影响后续高性能计算任务的执行。

#include <kupl/kupl_mem.h>  // KUPL内存管理头文件（用于内存优化）

// 优化1：使用KUPL内存管理接口，分配缓存友好的内存（适配鲲鹏多级内存架构）
// 替换原有的普通内存分配（如float A = 3.5f），使用KUPL内存分配接口：
float* A = (float*)kupl_mem_alloc(sizeof(float), KUPL_MEM_CACHE_L3);  // 分配L3缓存内存
float* B = (float*)kupl_mem_alloc(sizeof(float), KUPL_MEM_CACHE_L3);
*A = 3.5f;
*B = 2.0f;
// 解析：
// - kupl_mem_alloc：KUPL内存分配接口，可指定内存存储位置（L3缓存、主存）；
// - KUPL_MEM_CACHE_L3：将数据存储在L3缓存中，L3缓存访问延迟低，适合高频访问的数据；
// - 鲲鹏适配：鲲鹏920处理器的L3缓存容量大（每颗64MB），将高频访问的计算数据存储在L3缓存，
//   可大幅降低内存访问延迟，提升计算效率，尤其适合复杂迭代计算场景。

// 优化2：绑定线程到特定CPU核心（避免线程上下文切换）
// 在动态图创建后，添加线程绑定配置：
kupl_graph_attr_t graph_attr;
kupl_graph_attr_init(&graph_attr);  // 初始化动态图配置
graph_attr.thread_affinity = 1;     // 启用线程核心绑定
kupl_graph_t* graph = kupl_graph_create(KUPL_ALL_EXECUTORS, &graph_attr);
// 解析：
// - thread_affinity = 1：启用线程与CPU核心的绑定，动态图分配的线程会固定运行在特定核心上；
// - 鲲鹏适配：避免线程在不同核心间频繁切换，降低上下文切换开销，充分利用每个核心的算力，
//   尤其适合长时间运行的高性能计算任务，可提升任务执行的稳定性和效率。

// 优化3：开启编译优化（结合毕昇编译器的鲲鹏专属优化）
// 编译命令中添加更多优化选项：
// bishengcc -o kupl_graph_demo kupl_graph_demo.c -lkupl -lpthread -O2 -march=armv8.2