// 如果定义了__ARM_NEON__，则包含<arm_neon.h>头文件，用于支持ARM NEON指令集相关的操作
#ifdef __ARM_NEON__
#include <arm_neon.h>
#endif

// 定义向量的大小为1024
const int VECTOR_SIZE = 1024;
// 定义矩阵的大小为32（这里表示矩阵是32x32的）
const int MATRIX_SIZE = 32;

// 基础的向量加法函数
// 该函数实现了简单的向量加法操作，将输入向量a和b对应位置的元素相加，结果存储在result向量中
// 参数：
// a：输入向量a的指针
// b：输入向量b的指针
// result：用于存储相加结果的向量指针
// size：向量的元素个数
void vectorAddBase(float* a, float* b, float* result, int size) {
    // 循环遍历向量的每个元素
    for (int i = 0; i < size; ++i) {
        // 将a和b对应位置的元素相加，并存入result向量的对应位置
        result[i] = a[i] + b[i];
    }
}

// 如果定义了__ARM_NEON__，则执行以下NEON优化的向量加法函数
#ifdef __ARM_NEON__
// NEON优化的向量加法函数
// 该函数利用ARM NEON指令集对向量加法进行优化，以4个元素为一组进行处理（当向量大小是4的倍数时）
// 参数：
// a：输入向量a的指针
// b：输入向量b的指针
// result：用于存储相加结果的向量指针
// size：向量的元素个数
void vectorAddNeon(float* a, float* b, float* result, int size) {
    int i;
    // 以4个元素为一组进行处理，循环直到剩余元素不足4个
    for (i = 0; i <= size - 4; i += 4) {
        // 使用vld1q_f32指令将向量a中从索引i开始的4个元素加载到NEON寄存器vecA中
        float32x4_t vecA = vld1q_f32(&a[i]);
        // 使用vld1q_f32指令将向量b中从索引i开始的4个元素加载到NEON寄存器vecB中
        float32x4_t vecB = vld1q_f32(&b[i]);
        // 使用vaddq_f32指令对vecA和vecB中的对应元素进行加法操作，结果存储在vecResult中
        float32x4_t vecResult = vaddq_f32(vecA, vecB);
        // 使用vst1q_f32指令将vecResult中的4个元素存储回result向量中从索引i开始的位置
        vst1q_f32(&result[i], vecResult);
    }
    // 处理向量大小不是4的倍数时剩余的元素
    for (; i < size; ++i) {
        // 对于剩余元素，使用基础的加法方式将a和b对应位置的元素相加，并存入result向量的对应位置
        result[i] = a[i] + b[i];
    }
}
// 如果未定义__ARM_NEON__，则执行以下fallback操作，即调用基础的向量加法函数
#else
void vectorAddNeon(float* a, float* b, float* result, int size) {
    vectorAddBase(a, b, result, size); // Fallback to base implementation
}
#endif

// 基础的矩阵乘法函数
// 该函数实现了常规的矩阵乘法算法，按照矩阵乘法的规则计算两个矩阵A和B的乘积，结果存储在矩阵C中
// 参数：
// A：输入矩阵A的指针
// B：输入矩阵B的指针
// C：用于存储乘法结果的矩阵指针
// N：矩阵的边长（这里假设矩阵是方阵，所以只需要一个边长参数）
void matrixMultiplyBase(float* A, float* B, float* C, int N) {
    // 外层循环遍历矩阵A的行
    for (int i = 0; i < N; ++i) {
        // 内层循环遍历矩阵B的列
        for (int j = 0; j < N; ++j) {
            // 先将结果矩阵C中当前位置的元素初始化为0.0f
            C[i * N + j] = 0.0f;
            // 中间循环遍历矩阵A的列和矩阵B的行，用于计算乘积并累加
            for (int k = 0; k < N; ++k) {
                C[i * N + j] += A[i * N + k] * B[k * N + j];
            }
        }
    }
}

// 如果定义了__ARM_NEON__，则执行以下NEON优化的矩阵乘法函数
#ifdef __ARM_NEON__
// NEON优化的矩阵乘法函数
// 该函数利用ARM NEON指令集对矩阵乘法进行优化，以4个元素为一组处理矩阵B的列（当矩阵边长是4的倍数时）
// 参数：
// A：输入矩阵A的指针
// B：输入矩阵B的指针
// C：用于存储乘法结果的矩阵指针
// N：矩阵的边长（这里假设矩阵是方阵，所以只需要一个边长参数）
void matrixMultiplyNeon(float* A, float* B, float* C, int N) {
    // 外层循环遍历矩阵A的行
    for (int i = 0; i < N; ++i) {
        // 内层循环遍历矩阵B的列，每次处理4个元素一组
        for (int j = 0; j < N; j += 4) {
            // 使用vmovq_n_f32指令将浮点数0.0f初始化为NEON寄存器sum，用于累加乘积结果
            float32x4_t sum = vmovq_n_f32(0.0f);
            // 中间循环遍历矩阵A的列和矩阵B的行，用于计算乘积并累加
            for (int k = 0; k < N; ++k) {
                // 使用vdupq_n_f32指令复制矩阵A中当前行、当前列k对应的元素到NEON寄存器vecA中
                float32x4_t vecA = vdupq_n_f32(A[i * N + k]);
                // 使用vld1q_f32指令将矩阵B中当前列j从索引k开始的4个元素加载到NEON寄存器vecB中
                float32x4_t vecB = vld1q_f32(&B[k * N + j]);
                // 使用vfmaq_f32指令将vecA和vecB中的对应元素相乘，并累加到sum寄存器中
                sum = vfmaq_f32(sum, vecA, vecB);
            }
            // 使用vst1q_f32指令将sum寄存器中的4个元素存储回结果矩阵C中当前行、当前列j开始的位置
            vst1q_f32(&C[i * N + j], sum);
        }
    }
}
// 如果未定义__ARM_NEON__，则执行以下fallback操作，即调用基础的矩阵乘法函数
#else
void matrixMultiplyNeon(float* A, float* B, float* C, int N) {
    matrixMultiplyBase(A, B, C, N); // Fallback to base implementation
}
#endif

// 计算两个timespec结构体表示的时间点之间的时间差的函数
// 参数：
// start：起始时间点的timespec结构体
// end：结束时间点的timespec结构体
// 返回值：以秒为单位的时间差
double get_time_diff(struct timespec start, struct timespec end) {
    // 计算秒数差
    double diff_sec = end.tv_sec - start.tv_sec;
    // 计算纳秒数差
    double diff_nsec = end.tv_nsec - start.tv_nsec;
    // 将纳秒数差转换为秒并与秒数差相加，得到总时间差
    return diff_sec + diff_nsec / 1e9;
}

// 如果定义了_WIN32，说明是在Windows平台下，包含<windows.h>头文件，并定义以下函数
#ifdef _WIN32
#include <windows.h>

// 计算两个LARGE_INTEGER结构体表示的时间点之间的时间差的函数（用于Windows平台）
// 参数：
// start：起始时间点的LARGE_INTEGER结构体
// end：结束时间点的LARGE_INTEGER结构体
// frequency：时间频率的LARGE_INTEGER结构体
// 返回值：以秒为单位的时间差
double get_time_diff_windows(LARGE_INTEGER start, LARGE_INTEGER end, LARGE_INTEGER frequency) {
    // 计算经过的时间，通过两个时间点的QuadPart差值除以时间频率的QuadPart得到
    double elapsed = (double)(end.QuadPart - start.QuadPart) / frequency.QuadPart;
    // 返回计算得到的时间差
    return elapsed;
}
#endif