2024年国科大-高性能计算编程-作业二

最新推荐文章于 2024-08-03 18:36:56 发布
最新推荐文章于 2024-08-03 18:36:56 发布
阅读量402 收藏 5
点赞数 3
分类专栏： 期末复习 文章标签： c++ 性能优化 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Qudoudou2020/article/details/137230140
版权
文章详细描述了在Windows11系统上，使用CLion编译器和MinGW环境下，通过SoA（结构-of-arrays）方法以及对其内存对齐和循环展开的优化，提升代码运行效率的实验过程。结果显示，SoA优化显著提高了代码执行速度，但进一步的优化如内存对齐在某些处理器上效果不明显。
摘要由CSDN通过智能技术生成

作业题目

提交内容一：平台信息

  • 本次作业在Windows平台上进行了内容实现，具体平台信息如下

Windows平台

  • 系统：Win11-23H2

  • CPU：i9-13900HX(x86)

  • 内存：64G

  • IDE：CLion

  • 编译器：MinGW

提交内容二：原代码、SoA及各优化方式的运行结果

原代码的运行结果

SoA方式的运行结果

SoA方式下使用内存对齐进行优化的运行结果

SoA方式下使用循环展开进行优化的运行结果

数据统计

muladd,timingsumtiming
AoS731870us458269657059257us
SoA261313us458269657017589us
SoA_Align307924us458269657017527us
SoA_Unrolling263744us458269657017353us

提交内容三：分析各个版本的代码

  • 在windows中，无法使用perf进行代码的性能分析，因此我采用very sleepy对各个版本的代码进行分析
  • 为了使效果更加明显，我将各个版本的代码以函数的形式写在同一个cpp文件中，具体运行效果如下

  • 可以看到使用SoA分配方式以及在SoA的基础上再次进行内存对齐和循环展开优化后的代码在运行效率上高出源代码50%左右。这应该是由于SoA分配方式减少了大量的寻址工作所造成的。

  • 但是在SoA的基础上再次进行内存对齐和循环展开优化后的代码相比于SoA并没有太大的效率提升。这应该是由以下两个原因组成：

    • SoA分配方式所申请的内存是连续的内存块，已经保证了内存空间的连续分布

    • -O2编译时已经由编译器帮用户进行了适当的循环展开

  • 使用-O0命令再次编译后测试结果如下

  • 可以看到SoA已经保证了内存空间的连续分布，再次手动对齐反而可能造成时间的浪费

  • 如果不让编译器进行优化，而是手动对循环进行展开的话，是可以提升运行效率的。

  • 本次实验中手动的循环展开只展开了四次，所以效果不是很明显，具体代码见附录

自评分及理由

自评分

  • 10分（6+2+2）

理由

  • 提交作业要求的三个内容
  • 编写SoA及SoA基础上的内存对齐和循环展开代码，并收集这四种情况下的运行时间（6+2=8分）
  • 由于windows无法使用perf，使用very sleepy分析各个版本的代码运行时间，以及分析了产生运行时间差异的原因（2分）

附录


#include <cstdio>
#include <cstdlib>
#include <sys/time.h>
#include <cstdint>

inline int64_t GetUsec()
{
    struct timeval tv;
    gettimeofday(&tv, NULL);
    return (tv.tv_sec * 1000000l) + tv.tv_usec;
}

typedef struct
{
    double x;
    double y;
    double z;
} XYZ;

typedef struct
{
    double mass;
    XYZ acct;
    XYZ noused; // but here
    XYZ Velocity;
} Element;

const int ELEMENT_NUM = (4096 * 4096);

int homework2()
{

    Element *elements = new Element[ELEMENT_NUM];

    srand(202403);

    for (size_t ii = 0; ii < ELEMENT_NUM; ++ii)
    {
        elements[ii].mass = (double)(rand() % 10);

        elements[ii].acct.x = (double)(rand() % 10) - 5.0;
        elements[ii].acct.y = (double)(rand() % 10) - 5.0;
        elements[ii].acct.z = (double)(rand() % 10) - 5.0;

        elements[ii].Velocity.x = (double)(rand() % 10);
        elements[ii].Velocity.y = (double)(rand() % 10);
        elements[ii].Velocity.z = (double)(rand() % 10);
    }

    size_t start = GetUsec();
    double dt = 1.0;
    for (size_t step = 0; step < 10; ++step)
    {
        for (size_t ii = 0; ii < ELEMENT_NUM; ++ii)
        {
            elements[ii].Velocity.x += dt * elements[ii].acct.x;
            elements[ii].Velocity.y += dt * elements[ii].acct.y;
            elements[ii].Velocity.z += dt * elements[ii].acct.z;
        }
        dt = dt * (((rand() % 10) / 10.0) * 2.0);
    }

    size_t finish = GetUsec();
    printf("muladd,timing=%ldus\n", finish - start);

    start = GetUsec();

    double sum = 0.0;
    for (size_t ii = 0; ii < ELEMENT_NUM; ++ii)
    {
        sum += 0.5 * elements[ii].mass * (elements[ii].Velocity.x * elements[ii].Velocity.x + elements[ii].Velocity.y * elements[ii].Velocity.y + elements[ii].Velocity.z * elements[ii].Velocity.z);
    }
    finish = GetUsec();

    printf("sum = %.8e,timing=%ldus\n", sum, finish - start);

    delete[] elements;
    return 0;
}

typedef struct
{
    double *x;
    double *y;
    double *z;
} XYZ_SoA;

typedef struct
{
    double *mass;
    XYZ_SoA acct;
    XYZ_SoA noused; // but here
    XYZ_SoA Velocity;
} Element_SoA;

int homework2_SoA()
{

    Element_SoA elements;
    elements.mass = new double[ELEMENT_NUM];
    elements.acct.x = new double[ELEMENT_NUM];
    elements.acct.y = new double[ELEMENT_NUM];
    elements.acct.z = new double[ELEMENT_NUM];

    elements.noused.x = new double[ELEMENT_NUM];
    elements.noused.y = new double[ELEMENT_NUM];
    elements.noused.z = new double[ELEMENT_NUM];

    elements.Velocity.x = new double[ELEMENT_NUM];
    elements.Velocity.y = new double[ELEMENT_NUM];
    elements.Velocity.z = new double[ELEMENT_NUM];

    srand(202403);

    for (size_t ii = 0; ii < ELEMENT_NUM; ++ii)
    {
        elements.mass[ii] = (double)(rand() % 10);

        elements.acct.x[ii] = (double)(rand() % 10) - 5.0;
        elements.acct.y[ii] = (double)(rand() % 10) - 5.0;
        elements.acct.z[ii] = (double)(rand() % 10) - 5.0;

        elements.Velocity.x[ii] = (double)(rand() % 10);
        elements.Velocity.y[ii] = (double)(rand() % 10);
        elements.Velocity.z[ii] = (double)(rand() % 10);
    }

    size_t start = GetUsec();
    double dt = 1.0;
    for (size_t step = 0; step < 10; ++step)
    {
        for (size_t ii = 0; ii < ELEMENT_NUM; ++ii)
        {
            elements.Velocity.x[ii] += dt * elements.acct.x[ii];
            elements.Velocity.y[ii] += dt * elements.acct.y[ii];
            elements.Velocity.z[ii] += dt * elements.acct.z[ii];
        }
        dt = dt * (((rand() % 10) / 10.0) * 2.0);
        // SoA code below is slow  on AMD EPYC 7713 64-Core Processor.
        // Splitting into three loops is better way.
        /*for(size_t ii = 0; ii < ELEMENT_NUM; ++ii){
            ele_soa.vel_x[ii] += dt * ele_soa.acct_x[ii];
            ele_soa.vel_y[ii] += dt * ele_soa.acct_y[ii];
            ele_soa.vel_z[ii] += dt * ele_soa.acct_z[ii];
          }
        */
    }

    size_t finish = GetUsec();
    printf("muladd,timing=%ldus\n", finish - start);

    start = GetUsec();

    double sum = 0.0;
    for (size_t ii = 0; ii < ELEMENT_NUM; ++ii)
    {
        sum += 0.5 * elements.mass[ii] * (elements.Velocity.x[ii] * elements.Velocity.x[ii] + elements.Velocity.y[ii] * elements.Velocity.y[ii] + elements.Velocity.z[ii] * elements.Velocity.z[ii]);
    }
    finish = GetUsec();

    printf("sum = %.8e,timing=%ldus\n", sum, finish - start);
    return 0;
}

typedef struct
{
    double *x;
    double *y;
    double *z;
} XYZ_SoA_Align;

typedef struct
{
    double *mass;
    XYZ_SoA_Align acct;
    XYZ_SoA_Align noused; // but here
    XYZ_SoA_Align Velocity;
} Element_SoA_Align;

int homework2_SoA_Align()
{
    size_t alignment = 64;
    Element_SoA_Align elements;

    elements.mass = (double*)_aligned_malloc(ELEMENT_NUM * sizeof(double), alignment);
    elements.acct.x = (double*)_aligned_malloc(ELEMENT_NUM * sizeof(double), alignment);
    elements.acct.y = (double*)_aligned_malloc(ELEMENT_NUM * sizeof(double), alignment);
    elements.acct.z = (double*)_aligned_malloc(ELEMENT_NUM * sizeof(double), alignment);

    elements.noused.x = (double*)_aligned_malloc(ELEMENT_NUM * sizeof(double), alignment);
    elements.noused.y = (double*)_aligned_malloc(ELEMENT_NUM * sizeof(double), alignment);
    elements.noused.z = (double*)_aligned_malloc(ELEMENT_NUM * sizeof(double), alignment);

    elements.Velocity.x = (double*)_aligned_malloc(ELEMENT_NUM * sizeof(double), alignment);
    elements.Velocity.y = (double*)_aligned_malloc(ELEMENT_NUM * sizeof(double), alignment);
    elements.Velocity.z = (double*)_aligned_malloc(ELEMENT_NUM * sizeof(double), alignment);


    srand(202403);


    for (size_t ii = 0; ii < ELEMENT_NUM; ++ii)
    {
        elements.mass[ii] = (double)(rand() % 10);

        elements.acct.x[ii] = (double)(rand() % 10) - 5.0;
        elements.acct.y[ii] = (double)(rand() % 10) - 5.0;
        elements.acct.z[ii] = (double)(rand() % 10) - 5.0;

        elements.Velocity.x[ii] = (double)(rand() % 10);
        elements.Velocity.y[ii] = (double)(rand() % 10);
        elements.Velocity.z[ii] = (double)(rand() % 10);
    }

    size_t start = GetUsec();
    double dt = 1.0;
    for (size_t step = 0; step < 10; ++step)
    {
        for (size_t ii = 0; ii < ELEMENT_NUM; ++ii)
        {
            elements.Velocity.x[ii] += dt * elements.acct.x[ii];
            elements.Velocity.y[ii] += dt * elements.acct.y[ii];
            elements.Velocity.z[ii] += dt * elements.acct.z[ii];
        }
        dt = dt * (((rand() % 10) / 10.0) * 2.0);
    }

    size_t finish = GetUsec();
    printf("muladd,timing=%ldus\n", finish - start);

    start = GetUsec();

    double sum = 0.0;
    for (size_t ii = 0; ii < ELEMENT_NUM; ++ii)
    {
        sum += 0.5 * elements.mass[ii] * (elements.Velocity.x[ii] * elements.Velocity.x[ii] + elements.Velocity.y[ii] * elements.Velocity.y[ii] + elements.Velocity.z[ii] * elements.Velocity.z[ii]);
    }
    finish = GetUsec();

    printf("sum = %.8e,timing=%ldus\n", sum, finish - start);
    _aligned_free(elements.mass);
    _aligned_free(elements.acct.x);
    _aligned_free(elements.acct.y);
    _aligned_free(elements.acct.z);

    _aligned_free(elements.noused.x);
    _aligned_free(elements.noused.y);
    _aligned_free(elements.noused.z);

    _aligned_free(elements.Velocity.x);
    _aligned_free(elements.Velocity.y);
    _aligned_free(elements.Velocity.z);
    return 0;
}

typedef struct
{
    double *x;
    double *y;
    double *z;
} XYZ_SoA_Unrolling;

typedef struct
{
    double *mass;
    XYZ_SoA_Unrolling acct;
    XYZ_SoA_Unrolling noused; // but here
    XYZ_SoA_Unrolling Velocity;
} Element_SoA_Unrolling;

int homework2_SoA_Unrolling() {

    Element_SoA_Unrolling elements;
    elements.mass = new double[ELEMENT_NUM];
    elements.acct.x = new double[ELEMENT_NUM];
    elements.acct.y = new double[ELEMENT_NUM];
    elements.acct.z = new double[ELEMENT_NUM];

    elements.noused.x = new double[ELEMENT_NUM];
    elements.noused.y = new double[ELEMENT_NUM];
    elements.noused.z = new double[ELEMENT_NUM];

    elements.Velocity.x = new double[ELEMENT_NUM];
    elements.Velocity.y = new double[ELEMENT_NUM];
    elements.Velocity.z = new double[ELEMENT_NUM];

    srand(202403);

    for (size_t ii = 0; ii < ELEMENT_NUM; ++ii) {
        elements.mass[ii] = (double) (rand() % 10);

        elements.acct.x[ii] = (double) (rand() % 10) - 5.0;
        elements.acct.y[ii] = (double) (rand() % 10) - 5.0;
        elements.acct.z[ii] = (double) (rand() % 10) - 5.0;

        elements.Velocity.x[ii] = (double) (rand() % 10);
        elements.Velocity.y[ii] = (double) (rand() % 10);
        elements.Velocity.z[ii] = (double) (rand() % 10);
    }

    size_t start = GetUsec();
    double dt = 1.0;
    // Loop unrolling example
    for (size_t step = 0; step < 10; ++step) {
        for (size_t ii = 0; ii < ELEMENT_NUM; ii += 4) // Increase by 4 due to unrolling
        {
            elements.Velocity.x[ii] += dt * elements.acct.x[ii];
            elements.Velocity.y[ii] += dt * elements.acct.y[ii];
            elements.Velocity.z[ii] += dt * elements.acct.z[ii];

            // Unrolled operations
            if (ii + 1 < ELEMENT_NUM) {
                elements.Velocity.x[ii + 1] += dt * elements.acct.x[ii + 1];
                elements.Velocity.y[ii + 1] += dt * elements.acct.y[ii + 1];
                elements.Velocity.z[ii + 1] += dt * elements.acct.z[ii + 1];
            }
            if (ii + 2 < ELEMENT_NUM) {
                elements.Velocity.x[ii + 2] += dt * elements.acct.x[ii + 2];
                elements.Velocity.y[ii + 2] += dt * elements.acct.y[ii + 2];
                elements.Velocity.z[ii + 2] += dt * elements.acct.z[ii + 2];
            }
            if (ii + 3 < ELEMENT_NUM) {
                elements.Velocity.x[ii + 3] += dt * elements.acct.x[ii + 3];
                elements.Velocity.y[ii + 3] += dt * elements.acct.y[ii + 3];
                elements.Velocity.z[ii + 3] += dt * elements.acct.z[ii + 3];
            }
        }
        dt = dt * (((rand() % 10) / 10.0) * 2.0);
    }

    size_t finish = GetUsec();
    printf("muladd,timing=%ldus\n", finish - start);

    start = GetUsec();

    double sum = 0.0;
    for (size_t ii = 0; ii < ELEMENT_NUM; ii += 10) // Loop unrolling for sum calculation
    {
        sum += 0.5 * elements.mass[ii] * (elements.Velocity.x[ii] * elements.Velocity.x[ii]
                                          + elements.Velocity.y[ii] * elements.Velocity.y[ii]
                                          + elements.Velocity.z[ii] * elements.Velocity.z[ii]);
        sum += 0.5 * elements.mass[ii + 1] * (elements.Velocity.x[ii + 1] * elements.Velocity.x[ii + 1]
                                              + elements.Velocity.y[ii + 1] * elements.Velocity.y[ii + 1]
                                              + elements.Velocity.z[ii + 1] * elements.Velocity.z[ii + 1]);
        sum += 0.5 * elements.mass[ii + 2] * (elements.Velocity.x[ii + 2] * elements.Velocity.x[ii + 2]
                                              + elements.Velocity.y[ii + 2] * elements.Velocity.y[ii + 2]
                                              + elements.Velocity.z[ii + 2] * elements.Velocity.z[ii + 2]);
        sum += 0.5 * elements.mass[ii + 3] * (elements.Velocity.x[ii + 3] * elements.Velocity.x[ii + 3]
                                              + elements.Velocity.y[ii + 3] * elements.Velocity.y[ii + 3]
                                              + elements.Velocity.z[ii + 3] * elements.Velocity.z[ii + 3]);
    }
    finish = GetUsec();
    printf("sum = %.8e,timing=%ldus\n", sum, finish - start);
    return 0;
}

int main(){
    homework2();
    homework2_SoA();
    homework2_SoA_Align();
    homework2_SoA_Unrolling();
    return 0;
}
-Yuichi-
关注
  • 3
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
国科大Python编程基础--Chapter01绪论
weixin_41171614的博客
03-18 843
国科大Python编程基础--绪论Chapter01
国科大-计算机算法设计与分析讲义&PPT&平时作业及解答.zip
12-16
这门课程在国科大由刘玉贵老师讲授，涵盖了大量的理论知识和实践应用。刘玉贵老师的讲义、PPT以及平时的作业与解答为我们提供了深入学习这门课程的宝贵资源。 首先，讲义是课程内容的精华总结，通常包含了基础概念...
国科大——高性能计算系统习题1
qq_43840665的博客
03-02 1662
矩阵乘法（C++一维数组实现） #include<iostream> using namespace std; class matirx { private: int rows;// 矩阵行数 int cols;// 矩阵列数 int* mValue;// 矩阵的值 public: // 标准构造函数格式 matirx() {} // 获取输入 void initMatirx() { // 获取矩阵的行列和值 cout << "请输入行数：";.
高性能计算机系统 胡伟武 中科研计算所
03-02
高性能计算机系统 胡伟武 主要描述龙芯一号CPU的工作原理！ 学计算机的人都应该学习！
2024年国科大-高性能计算编程-作业六
Qudoudou2020的博客
05-25 416
2024年国科大-高性能计算编程-作业六
2024年国科大-高性能计算编程-作业五
Qudoudou2020的博客
05-10 1085
2024年国科大-高性能计算编程-作业五
2024年国科大-高性能计算编程-作业一
Qudoudou2020的博客
04-01 665
2024年国科大 高性能计算编程 作业一
2024华为OD机试D卷 - 小朋友分组最少调整，包含多种语
2301_78234743的博客
07-08 955
本人双非民办本科，现在大三下，无实习过，刚找到一个外企实习，但得实习一年而且无转正，值不值得去，去了。#我的简历长这样# #开发岗位# #Java# 投了很多实习，一个面试也没有，到底是哪里出问题了。求助大佬刚实习不久，看项目代码，如何快速学习大型项目代码，并聚焦看懂自己负责的模块，并进行添加功能？#软件开发薪资爆料# 看背景以为是什么财大气粗的好公司，实则里面是技术也没有，马内也没有，唯一好处朝。一年一度的秋招即将开始，每一个经历过秋招的同学都会有自己的酸甜苦辣，去年秋招的同学们，有什么告诫今年。
从关键新闻和最新技术看AI行业发展（2024.5.6-5.19第二十三期） |【WeThinkIn老实人报】
欢迎大家关注我
05-26 828
阅读【WeThinkIn老实人报】，掌握最新AI行业资讯，提升个人基本面。
2024届CV与数据分析校招信息汇总(持续更新中)
专注“目标检测”领域技术分享
09-03 7830
找寻的岗位：CV、数据分析NLP和RS、物联网、大数据开发、java开发、C++开发岗位、测试岗 也会统计——用于判断是否需要学点NLP和RS，投投这个领域的。万一NLP尤其是大模型领域岗位特别多，那我就应该学一学，去撞撞运气实习的只会记录岗位的名字——用于判断现在实习生招什么岗位需求大，要是未来实在找不到工作，先找个实习，积累点项目经验也是一条退路。
2023-2024-国科大-生物信息学-考试原题
01-10
1. 2023-2024_国科大_生物信息学_考试原题 2. 直接看完这个，考试嘎嘎过 3. 看完你就知道，csdn总结的那份材料的重要性，因为都是原题
国科大-并行与分布式计算配套实验.zip
06-02
国科大-并行与分布式计算配套实验.zip
国科大-机器学习与模式识别-第三次作业
01-22
国科大-机器学习与模式识别-第三次作业国科大-机器学习与模式识别-第三次作业国科大-机器学习与模式识别-第三次作业
2024年度最佳 | 国内外AI大模型哪家强？
2401_85375151的博客
07-18 1174
AI大模型在技术、应用和市场等方面展现出了前所未有的蓬勃发展态势，各行各业都在广泛使用AI大模型，例如搭建AI知识库以科学管理企业知识，这一趋势不仅标志着人工智能技术的飞跃性进步，也预示着未来社会的深刻变革和广泛应用前景。接下来就盘点一下国内外的热门AI大模型吧。
OpenGL3.3_C++_Windows(32)
sengyongan的博客
07-29 409
demo SSAO SSAO 环境光照(Ambient Lighting)：光的散射，我们通过一个固定的常量作为环境光的模拟， 但是这种固定的环境光并不能很好模拟散射，因为环境光不是一成不变的， 环境光遮蔽：让（褶皱、孔洞）等变暗的方法近似模拟出间接光照，但是这一技术会带来很大的性能开销，因为它还需要考虑周围的几何体。 屏幕空间环境光遮蔽(Screen-Space Ambient Occlusion, SSAO)：这一技术使用了屏幕空间场景的深度而不是真实的几何体数据来确定遮蔽量。 原理：对
【C++】输入输出
2401_83948390的博客
08-02 493
在C++中，输入输出操作主要通过标准库中的iostream头文件提供的一系列对象和函数来完成。
二叉树的中序遍历 - 力扣（LeetCode）C语言
最新发布
SikJ_2020_0_24的博客
08-03 168
注：本题中returnSize，指的是二叉树的结点数，返回的必须是malloc开辟的。递归算法很简单，你可以通过迭代算法完成吗？注意要点与前序遍历相同，请参考。（点击前面链接即可查看题目）给定一个二叉树的根节点。
澳科大高性能计算平台用户使用手册
"澳科大高性能计算平台用户使用手册-20180417.pdf" 这份用户使用手册是针对澳门科技大学建设的高性能计算平台，由曙光星云信息产业（北京）有限公司在2017年编撰。该手册详细介绍了如何使用这个平台，对于学习和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值