CSAPP Lab05——Performance Lab完成思路

最新推荐文章于 2024-06-27 13:23:38 发布
最新推荐文章于 2024-06-27 13:23:38 发布
阅读量694 收藏 24
点赞数 13
文章标签： CSAPP cmu15213 wsl2 vscode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/john_snowww/article/details/139409518
版权

You sing me your melody and I feel so please

I want you to want me to keep your dream

Together we'll run wild by a summer symphony

This is what we enjoyed not a fantasy

——Young For You

完整代码见：CSAPP/perflab-handout at main · SnowLegend-star/CSAPP (github.com)

总的来说，这次的lab难度比上个要低很多。而且两者的本质又十分类似，故完成本lab的时间算是最近几个lab里面最短的。

Part A: Rotate

Part A是要求把一个矩阵src逆时针旋转90°后存储到矩阵dst里面，有趣的是这次的矩阵都是用以一维的形式存储的，所以操作起来要比二维更绕一点。有了上次cache lab的经验，我上来就打算用到分块加上循环展开的思路。

这次由于被测试的矩阵大小从32×32到1024×1024，所以再笼统地把分块定为8×8肯定是不妥当的。同时本次lab没有给出cache的大小，所以我测试了8×8、16×16、32×32等不同尺度的分块，最终发现32×32的分块尺度是最佳的。找到分块大小后，就可以着手循环展开了。我一下子定义了32个变量，先把src矩阵一个块内一整行的元素赋值给变量，再用变量给dst赋值过去。结果效率反而还变低了，搞得我有点一头雾水。几经思考发现我定义32个变量的举动确实有点呆，书上定义变量acc是为了减少访问内存的次数，因为这个变量acc是被存在寄存器上的。我定义这么多变量首先是以为用变量作为中介实现src给dst的赋值会减少访问内存的次数，实则不然，这样反而增加了访问时间，本来src可以直接赋值给dst，我再加入个第三者无异于画蛇添足。其次，计算机的通用寄存器是一定的，变量个数如果超过可以存变量的寄存器个数，那剩下的变量就会存储在内存中，导致访问内存的次数再次增长。

最终的后果是定义32个变量的负面效果大于分块带来的正面效果，是程序的运行速度反而变慢了。效果如下图：

后来我又想到了个优化的方法，原函数在计算数组下标时每次都要调用一次“RIDX()”函数，要是只在第一次调用这个函数计算当前访问的元素下标Xi ，后序直接在Xi 的基础上进行加法运算，那效果如何呢？

事实证明这方法有点东西，但是不多。因为“RIDX()”函数内部的运行时间与数组的规模n无关，所以调用这个函数的时间是个很小的常数。

 

最后一个提升的方法比较隐晦，我也是参考了其他人的想法——写不命中的开销比读不命中的代价更大，因此得保证对dst数组的访问是按序递增的，而对src数组的访问可以跳着来。通俗地解释就是访问了dst[0][1]后接下来访问dst[0][2]效率比较高，而不是原函数的访问了dst[1][0]后再访问dst[2][0]。可以看到效果确实大幅度提升了。 

 

那么最后的优化方法就是：分块+循环展开+减少函数调用+写优先了

 

不过可疑的是，我刚才又测试了下16×16的分块效果，居然要比32×32的要好一点点，真是奇怪。通过和网上的解决方法对比，可以发现效果基本差不多。

 

 

 这里就只提供效果最好的一份供大家参考了

char rotate_descr_bolck_loopUnroll_codeMove_wrtFirst[] = "rotate: 分块+循环展开+采用写优先";
void rotate_32X32_loopUnroll_codeMove_wrtFirst(int dim, pixel *src, pixel *dst){
    int i,j,k;
    int bsize=32;

    for(i=0;i<dim;i+=bsize)
        for(j=0;j<dim;j+=bsize){
            for(k=0;k<bsize;k++){
                    dst[RIDX(dim-1-(i+k), j+0, dim)] = src[RIDX(j+0, i + k, dim)];
                    dst[RIDX(dim-1-(i+k), j+1, dim)] = src[RIDX(j+1, i + k, dim)];
                    dst[RIDX(dim-1-(i+k), j+2, dim)] = src[RIDX(j+2, i + k, dim)];
                    dst[RIDX(dim-1-(i+k), j+3, dim)] = src[RIDX(j+3, i + k, dim)];
                    dst[RIDX(dim-1-(i+k), j+4, dim)] = src[RIDX(j+4, i + k, dim)];
                    dst[RIDX(dim-1-(i+k), j+5, dim)] = src[RIDX(j+5, i + k, dim)];
                    dst[RIDX(dim-1-(i+k), j+6, dim)] = src[RIDX(j+6, i + k, dim)];
                    dst[RIDX(dim-1-(i+k), j+7, dim)] = src[RIDX(j+7, i + k, dim)];
                    dst[RIDX(dim-1-(i+k), j+8, dim)] = src[RIDX(j+8, i + k, dim)];
                    dst[RIDX(dim-1-(i+k), j+9, dim)] = src[RIDX(j+9, i + k, dim)];
                    dst[RIDX(dim-1-(i+k), j+10, dim)] = src[RIDX(j+10, i + k, dim)];
                    dst[RIDX(dim-1-(i+k), j+11, dim)] = src[RIDX(j+11, i + k, dim)];
                    dst[RIDX(dim-1-(i+k), j+12, dim)] = src[RIDX(j+12, i + k, dim)];
                    dst[RIDX(dim-1-(i+k), j+13, dim)] = src[RIDX(j+13, i + k, dim)];
                    dst[RIDX(dim-1-(i+k), j+14, dim)] = src[RIDX(j+14, i + k, dim)];
                    dst[RIDX(dim-1-(i+k), j+15, dim)] = src[RIDX(j+15, i + k, dim)];
                    dst[RIDX(dim-1-(i+k), j+16, dim)] = src[RIDX(j+16, i + k, dim)];
                    dst[RIDX(dim-1-(i+k), j+17, dim)] = src[RIDX(j+17, i + k, dim)];
                    dst[RIDX(dim-1-(i+k), j+18, dim)] = src[RIDX(j+18, i + k, dim)];
                    dst[RIDX(dim-1-(i+k), j+19, dim)] = src[RIDX(j+19, i + k, dim)];
                    dst[RIDX(dim-1-(i+k), j+20, dim)] = src[RIDX(j+20, i + k, dim)];
                    dst[RIDX(dim-1-(i+k), j+21, dim)] = src[RIDX(j+21, i + k, dim)];
                    dst[RIDX(dim-1-(i+k), j+22, dim)] = src[RIDX(j+22, i + k, dim)];
                    dst[RIDX(dim-1-(i+k), j+23, dim)] = src[RIDX(j+23, i + k, dim)];
                    dst[RIDX(dim-1-(i+k), j+24, dim)] = src[RIDX(j+24, i + k, dim)];
                    dst[RIDX(dim-1-(i+k), j+25, dim)] = src[RIDX(j+25, i + k, dim)];
                    dst[RIDX(dim-1-(i+k), j+26, dim)] = src[RIDX(j+26, i + k, dim)];
                    dst[RIDX(dim-1-(i+k), j+27, dim)] = src[RIDX(j+27, i + k, dim)];
                    dst[RIDX(dim-1-(i+k), j+28, dim)] = src[RIDX(j+28, i + k, dim)];
                    dst[RIDX(dim-1-(i+k), j+29, dim)] = src[RIDX(j+29, i + k, dim)];
                    dst[RIDX(dim-1-(i+k), j+30, dim)] = src[RIDX(j+30, i + k, dim)];
                    dst[RIDX(dim-1-(i+k), j+31, dim)] = src[RIDX(j+31, i + k, dim)];

            }   
        }
}

 

#define COPY(d,s) *(d)=*(s)

char rotate_descr_bolck_loopUnroll_copyOL[] = "rotate: 分块+循环展开(网上搬来的)";
void rotate_32X32_loopUnroll_copyOL(int dim, pixel *src, pixel *dst){
int i,j;
   for(i=0;i<dim;i+=32)//32路循环展开，32个像素依次存储
         for(j=dim-1;j>=0;j-=1){       
         pixel*dptr=dst+RIDX(dim-1-j,i,dim);
         pixel*sptr=src+RIDX(i,j,dim);
        //进行复制操作
            COPY(dptr,sptr);sptr+=dim;
            COPY(dptr+1,sptr);sptr+=dim;
            COPY(dptr+2,sptr);sptr+=dim;
            COPY(dptr+3,sptr);sptr+=dim;
            COPY(dptr+4,sptr);sptr+=dim;
            COPY(dptr+5,sptr);sptr+=dim;
            COPY(dptr+6,sptr);sptr+=dim;
            COPY(dptr+7,sptr);sptr+=dim;
            COPY(dptr+8,sptr);sptr+=dim;
            COPY(dptr+9,sptr);sptr+=dim;
            COPY(dptr+10,sptr);sptr+=dim;
            COPY(dptr+11,sptr);sptr+=dim;
            COPY(dptr+12,sptr);sptr+=dim;
            COPY(dptr+13,sptr);sptr+=dim;
            COPY(dptr+14,sptr);sptr+=dim;
            COPY(dptr+15,sptr);sptr+=dim;
            COPY(dptr+16,sptr);sptr+=dim;
            COPY(dptr+17,sptr);sptr+=dim;
            COPY(dptr+18,sptr);sptr+=dim;
            COPY(dptr+19,sptr);sptr+=dim;
            COPY(dptr+20,sptr);sptr+=dim;
            COPY(dptr+21,sptr);sptr+=dim;
            COPY(dptr+22,sptr);sptr+=dim;
            COPY(dptr+23,sptr);sptr+=dim;
            COPY(dptr+24,sptr);sptr+=dim;
            COPY(dptr+25,sptr);sptr+=dim;
            COPY(dptr+26,sptr);sptr+=dim;
            COPY(dptr+27,sptr);sptr+=dim;
            COPY(dptr+28,sptr);sptr+=dim;
            COPY(dptr+29,sptr);sptr+=dim;
            COPY(dptr+30,sptr);sptr+=dim;
            COPY(dptr+31,sptr);
   }
}

 

Part B: Smooth

Part B的avg函数一眼望去全是漏洞：

  • 在循环体内调用min、max函数
  • 重复计算了许多元素和，导致效率低
  • avg函数包含好几个函数调用，可能在调用函数的同时也会浪费不少时间

为了提升代码的运行效率，考虑把所有的运算步骤写进一个函数，牺牲代码可读性来换取效率。代码大致分为三大块：四个顶点，四条边上的点和内部的点。有点要吐槽的是这个lab用的是c语言，导致无法对“+”进行重载，每次都要把c++一行代码可以解决的分成三行来写，分别处理blue、green、red。偏偏点情况还有三类，直接汗流浃背了。

为了解决原函数存在的计算冗余问题，我的想法是利用下简单的dp思想：

首先用一个大小为(dim+2)×(dim+2)的二维矩阵C把src包起来，矩阵C四条边上的元素全部置0。这样我们只用处理C[1][1]~C[dim][dim]这个区间里面的元素，且所有元素的计算方法都是算九个点的和再平均，不用考虑三类特殊的点。

同时用变量tmp存储C[i][j]周围九个点的和，计算C[i][j+1]周围九个点的和时，就可以用tmp-C[i][j-2]那列三个元素和+C[i][j+1]三个元素和得到，有效利用了六个点的计算和。而每一行第一个元素C[i][1]的周围九个点的和也可以通过c[i-1][1]的九点和更快地得到。

由于在VS会有结构体的成员提示，而VSCode只能自己把结构体对应的成员打上去，于是我就打算在VS上完成。写的差不多的时候发现我把src、dst全都当做二维数组来写了，tmd，真是功亏一篑。遂道心受损，直接写了份没用dp思想的代码凑合过了。

虽然smooth用不到分块，但是运行效果还是有巨大的提升。

 

 

 

/*
 * smooth - Your current working version of smooth. 
 * IMPORTANT: This is the version you will be graded on
 */
char smooth_descr[] = "smooth: Current working version";
void smooth(int dim, pixel *src, pixel *dst)
{
    int i,j;
    int dim0=dim;
    int dim1=dim-1;
    int dim2=dim-2;
    pixel *P1, *P2, *P3;
    pixel *dst1;
    P1=src;
    P2=P1+dim0;
    //左上角像素处理
    dst->red=(P1->red+(P1+1)->red+P2->red+(P2+1)->red)>>2;
    dst->green=(P1->green+(P1+1)->green+P2->green+(P2+1)->green)>>2;
    dst->blue=(P1->blue+(P1+1)->blue+P2->blue+(P2+1)->blue)>>2;
    dst++;
    //上边界处理
    for(i=1;i<dim1;i++)
    {
        dst->red=(P1->red+(P1+1)->red+(P1+2)->red+P2->red+(P2+1)->red+(P2+2)->red)/6;
        dst->green=(P1->green+(P1+1)->green+(P1+2)->green+P2->green+(P2+1)->green+(P2+2)->green)/6;
        dst->blue=(P1->blue+(P1+1)->blue+(P1+2)->blue+P2->blue+(P2+1)->blue+(P2+2)->blue)/6;
        dst++;
        P1++;
        P2++;
    }
    //右上角像素处理
    dst->red=(P1->red+(P1+1)->red+P2->red+(P2+1)->red)>>2;
    dst->green=(P1->green+(P1+1)->green+P2->green+(P2+1)->green)>>2;
    dst->blue=(P1->blue+(P1+1)->blue+P2->blue+(P2+1)->blue)>>2;
    dst++;
    P1=src;
    P2=P1+dim0;
    P3=P2+dim0;
    //左边界处理
    for(i=1;i<dim1;i++)
    {
        dst->red=(P1->red+(P1+1)->red+P2->red+(P2+1)->red+P3->red+(P3+1)->red)/6;
        dst->green=(P1->green+(P1+1)->green+P2->green+(P2+1)->green+P3->green+(P3+ 1)->green)/6;
        dst->blue=(P1->blue+(P1+1)->blue+P2->blue+(P2+1)->blue+P3->blue+(P3+1)->blue)/6;
        dst++;
        dst1=dst+1;
        //中间主体部分处理
        for(j=1;j<dim2;j+=2)
        {        
            //同时处理两个像素
           dst->red=(P1->red+(P1+1)->red+(P1+2)->red+P2->red+(P2+1)->red+(P2+2)->red+P3->red+(P3+1)->red+(P3+2)->red)/9;
           dst->green=(P1->green+(P1+1)->green+(P1+2)->green+P2->green+(P2+1)->green+(P2+2)->green+P3->green+(P3+1)->green+(P3+2)->green)/9;
           dst->blue=(P1->blue+(P1+1)->blue+(P1+2)->blue+P2->blue+(P2+1)->blue+(P2+2)->blue+P3->blue+(P3+1)->blue+(P3+2)->blue)/9;
           dst1->red=((P1+3)->red+(P1+1)->red+(P1+2)->red+(P2+3)->red+(P2+1)->red+(P2+2)->red+(P3+3)->red+(P3+1)->red+(P3+2)->red)/9;
           dst1->green=((P1+3)->green+(P1+1)->green+(P1+2)->green+(P2+3)->green+(P2+1)->green+(P2+2)->green+(P3+3)->green+(P3+1)->green+(P3+2)->green)/9;
           dst1->blue=((P1+3)->blue+(P1+1)->blue+(P1+2)->blue+(P2+3)->blue+(P2+1)->blue+(P2+2)->blue+(P3+3)->blue+(P3+1)->blue+(P3+2)->blue)/9;
           dst+=2;
           dst1+=2;
           P1+=2;
           P2+=2;
           P3+=2;
        }
        for(;j<dim1;j++)
        {         
           dst->red=(P1->red+(P1+1)->red+(P1+2)->red+P2->red+(P2+1)->red+(P2+2)->red+P3->red+(P3+1)->red+(P3+2)->red)/9;
           dst->green=(P1->green+(P1+1)->green+(P1+2)->green+P2->green+(P2+1)->green+(P2+2)->green+P3->green+(P3+1)->green+(P3+2)->green)/9;
           dst->blue=(P1->blue+(P1+1)->blue+(P1+2)->blue+P2->blue+(P2+1)->blue+(P2+2)->blue+P3->blue+(P3+1)->blue+(P3+2)->blue)/9;
           dst++;
           P1++;
           P2++;
           P3++;
        }
        //右侧边界处理
        dst->red=(P1->red+(P1+1)->red+P2->red+(P2+1)->red+P3->red+(P3+1)->red)/6;
        dst->green=(P1->green+(P1+1)->green+P2->green+(P2+1)->green+P3->green+(P3+1)->green)/6;
        dst->blue=(P1->blue+(P1+1)->blue+P2->blue+(P2+1)->blue+P3->blue+(P3+1)->blue)/6;
        dst++;
        P1+=2;
        P2+=2;
        P3+=2;
     } 
    //右下角处理
     dst->red=(P1->red+(P1+1)->red+P2->red+(P2+1)->red)>>2;
     dst->green=(P1->green+(P1+1)->green+P2->green+(P2+1)->green)>>2;
     dst->blue=(P1->blue+(P1+1)->blue+P2->blue+(P2+1)->blue)>>2;
     dst++;
    //下边界处理
     for(i=1;i<dim1;i++)
     {
        dst->red=(P1->red+(P1+1)->red+(P1+2)->red+P2->red+(P2+1)->red+(P2+2)->red)/6;
        dst->green=(P1->green+(P1+1)->green+(P1+2)->green+P2->green+(P2+1)->green+(P2+2)->green)/6;
        dst->blue=(P1->blue+(P1+1)->blue+(P1+2)->blue+P2->blue+(P2+1)->blue+(P2+2)->blue)/6;
        dst++;
        P1++;
        P2++;
     } 
    //右下角像素处理
     dst->red=(P1->red+(P1+1)->red+P2->red+(P2+1)->red)>>2;
     dst->green=(P1->green+(P1+1)->green+P2->green+(P2+1)->green)>>2;
     dst->blue=(P1->blue+(P1+1)->blue+P2->blue+(P2+1)->blue)>>2;
 }

总的来说这次的lab确实轻松，思维难度也没前面的那么高，就是有点麻烦，得对比各种改进的效率。一言蔽之，还算是一个比较愉快的思维交锋。 

John_Snowww
关注
CSAPP实验四：性能优化实验（Perflab）
CNFINITE的博客
08-12 1万+
本系列文章为中国科学技术大学计算机专业学科基础课《计算机系统》布置的实验，上课所用教材和内容为黑书CSAPP，当时花费很大精力和弯路，现来总结下各个实验，本文章为第四个实验——性能优化实验（Perflab）。 一、实验名称：perflab 二、实验学时： 3 三、实验内容和目的： 此次实验进行图像处理代码的优化。图像处理提供了许多能够通过优化而得到改良的函数。在此次实验中，我们将考虑两种图像处理操作：roate， 此函数用于将图像逆时针旋转90°；以及smooth，对图像...
CSAPP Lab4: Performance Lab
crazyliu的博客
12-30 1179
本文为USTC SSE CSAPP 2020 Fall实验三的记录，仅供参考 PPT链接在这里：Lab 4.pptx 代码在这里kernels.c
csapp实验6-perflab实验详解
m0_65591847的博客
08-16 585
csapp的第六个perflab实验，实验很粗糙，我做的也很粗糙，感觉意义不大
[CSAPP] Performance Lab 实验笔记
康宇的博客
07-06 3350
perflab这节的任务是利用书中知识，来对图像处理中的Rotate和Smooth操作函数进行优化。这次没对上电波，觉得学了一堆屠龙之技。于我个人理解，现在计算机配置比以前高多了，连SWAP分区都几近废弃了，对于一般开发者来讲，代码效率瓶颈首先是架构，其次是算法，最后才是书里教的这些小细节。而且这节也没个具体的分数标准，优化了半天也不知道自己写的算啥水平，缺了前面几节那种攻克难题的成就感。不过也有可能是因为我太菜了 XD 前期准备 这次的开发环境被我迁移到了WSL上，系统版本为ubuntu 18.04 LT
CSAPP-Lab5 CacheLab解析
Lineng's blog
12-18 702
读取矩阵A时，会缓存A0、A1两个4x4的分块，如果只是单纯的4x4分块中，A1的缓存是会被浪费的，在这里为了充分利用缓存，我们把A1也存到矩阵B中相同位置上，但我们知道这个位置是错误的，所以用本地变量把此时矩阵B分块的右上角的4x4分块存起来。次，我们讨论分块大小该怎么设置：变大后的矩阵，原来的缓存只够存下4行，如果分块超过4行，那么矩阵内部就会出现重叠。来说，是行读取，步数为1，每个block的第一个元素会miss，后面7个都会hint，即每8个元素miss一次，一行n个元素，miss。
HIT CSAPP 自设实验 Lab5 链接 Linkbomb 解析
热门推荐
hahalidaxin的专栏
11-23 1万+
之前的方法太坑了，我更新了一下phase2_(:з」∠)_ 55555 直接复制过来排版太烂，我也懒得改了_(:з」∠)_，如果看的不舒服，移步： hahalidaxin's Github update：关于0xffffffa6为什么反汇编之后会变？其实是我call指令用错啦，举个例子： 所以实际应该在getcode.s里面填0xffffffaa才对，不过意思到了就行，下面...
csapp lab archlab 解答
03-23
《csapp lab archlab 解答》 在计算机科学领域，"csapp"通常指的是《Computer Systems: A Programmer's Perspective》这本书，它是一本深入讲解计算机系统原理的经典教材。"archlab"则是书中针对体系结构...
CSAPP: 极度舒适的Perflab
Rachel_IS的博客
05-17 1891
最近的lab和pj太多了5555 每天写一点叭…要加油鸭！！ Perflab 共两个函数 rotate & smooth 需要优化性能 CPE越低越好 but竟然没有评分标准的嘛… 5.15：rotate优化至13.9 原始版本： 性能： 改进1：32*32块划分 注意这里调换了原本的RIDX(dim-1-j, i, dim)的i/j顺序，性能提升不少性能： 改进2：循环4路展开 性能： 改进3：32*32块+指针 but为什么用指针更好呢？应该是避免重复计算地址叭～ 这里是我自己的构思，
深入理解计算机系统CSAPP-perfLab：kernels.c性能优化实验：smooth优化详细实验日志（含四个优化版本）
乔卿的博客
11-08 9567
目录一、实验内容二、相关知识1、 平滑处理流程2、 平滑计算过程1) 四个顶点2) 除顶点外的四条边上的像素点3) 其他像素点3、 服务器与本地计算机之间复制文件的方法1) 把本地文件拷贝到服务器2) 把服务器文件拷贝到本地计算机4、 常见性能优化方法5、 Makefile规则6、64位系统中RGB像素点(结构体)的存储7、 数组在内存中的存储原理三、实验步骤四、 程序优化各个版本写在前面1、 添...
CSAPP Lab4- PerfLab
青衫客36的博客
05-21 1474
在kernel.c中有rotate的实现方法，我们需要添加自己的rotate实现，函数名自己命名，然后通过把自己实现的函数注册进去。
ics lab8 perflab性能优化实验
10-31
自己写的csapp上的性能优化实验的kernels.c。
关于csapp perflab的资源总结.docx
06-15
csapp hitsz 课程资源 这是自己看csapp的一点心得 感觉对同学可能有所帮助 里面的ppt讲的不完全对
csapp cache lab 满分原创（北大&cmu;） 仅供参考，请勿抄袭
12-27
csapp cache lab 满分原创（北大&cmu;） 仅供参考，请勿抄袭
哈工大计算机系统Lab5 报告+源代码，供学弟学妹参考。
08-25
哈工大计算机系统Lab5 报告+源代码，供学弟学妹参考。
CSAPP Lab 5:Writing a Dynamic Storage Allocator实验材料
03-11
《深入理解计算机系统》课程的实验5材料 解答过程在：http://blog.csdn.net/u010560443/article/details/50611251
CSAPP(CMU 15-213)：Lab5 Shlab详解
qq_42241839的博客
03-02 1192
# 前言 本系列文章意在记录答主学习CSAPP Lab的过程，也旨在可以帮助后人一二，欢迎大家指正！ tips:本lab主要是为了更加熟悉进程控制和信号的概念！！要完成一个支持简易作业控制的shell程序。 Shell这样的交互型程序主要负责管控用户所运行程序进程，并负责给各个子进程分配信号以完成要求！！！ handout 实现函数【参考代码行数】 所给的资料已经拥有一个shell程序的功能框架，我们只需完成有关作业控制的几个关键函数即可。（tsh.c） eval：分析和解释命令行的主例程【70行】
CSAPP-Lab5_shelllab
最新发布
2401_84974736的博客
06-27 722
本lab是编写一个支持作业控制的简单Unix shell程序，运用 waitpid, kill, fork, execve, setpgid, sigprocmask等，会让我们更加熟悉过程控制和信号的概念。
深入理解计算机系统CSAPP-perfLab：kernels.c性能优化实验：rotate优化详细实验日志（含六个优化版本）
乔卿的博客
11-05 1万+
目录一、实验内容二、相关知识三、实验步骤四、 程序优化各个版本初始版本版本一：分块，旨在提高空间局部性版本二：在分块的基础上，循环展开(降低了循环开销，但牺牲程序的尺寸)版本三：在前两个版本的基础上，改善读写顺序版本四：修改pixel结构，旨在令每一个像素点占1整个块版本五：消除函数调用并改善读写顺序。版本六：改善读写顺序并循环站靠。五、遇到的问题及解决方法 一、实验内容 1、 学习图像旋转与图像...
CSAPP 六个重要实验 lab3 实验材料
09-15
CSAPP 六个重要实验 lab3 实验材料CSAPP 六个重要实验 lab3 实验材料
CSAPP bomblab实验：二进制炸弹解除指南
CSAPP bomblab实验报告 CSAPP bomblab是卡内基梅隆大学（CMU）CSAPP课程实验lab系列中的一个实验，旨在帮助学生理解汇编语言和使用gdb调试工具。实验的主要目的是让学生通过反汇编和逆向工程来确定六个字符串，从而...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值