c - 通过C中的预取和缓存优化对阵列的线性访问-6ren

c - 通过C中的预取和缓存优化对阵列的线性访问

转载作者：IT王子更新时间：2023-10-28 23:30:04

披露：我在programmers.stack上尝试过类似的问题，但那个地方离活动stack远不近。
简介
我喜欢用大量的大图片。它们也有多个序列，必须反复处理和回放。有时我使用GPU，有时使用CPU，有时两者都使用。大多数访问模式本质上是线性的（来回），这让我想到了关于数组的更基本的事情，以及一种编写代码的方法应该如何优化给定硬件上的最大内存带宽（允许计算不会阻塞读/写）。
测试规范
我在2011年的MacBookAir4,2（i5-2557m）上完成了这个操作，它带有4GB内存和SSD。在测试期间，除了ITerm2，没有其他任何东西在运行。
GCC 5.2.0（自制），带有标志：-pedantic -std=c99 -Wall -Werror -Wextra -Wno-unused -O0和附加的include和library标志以及框架标志，以便使用我倾向于使用的glfw计时器。我本来可以不用的，没关系。当然是64位的。
我尝试过带有可选-fprefetch-loop-arrays标志的测试，但它似乎根本没有影响结果。
试验
在堆上分配两个n bytes数组-其中n是8, 16, 32, 64, 128, 256, 512 and 1024 MB
初始化array到0xff，字节一次
测试1-线性拷贝
线性副本：

for(uint64_t i = 0; i < ARRAY_NUM; ++i) {
        array_copy[i] = array[i];
    }

测试2-用步幅复制。这就是让人困惑的地方。我试过在这里玩预购游戏。我尝试过各种组合，每一个循环应该做多少，似乎每一个循环大约40次可以获得最佳性能。为什么？我不知道。我知道，C99中的 malloc和 uint64_t会给我内存对齐的块。我还看到了我的l1到l3缓存的大小，它们高于这些缓存，那么我要命中什么呢？线索可能在图表后面。我很想理解这一点。
跨步复制：

for(uint64_t i = 0; i < ARRAY_NUM; i=i+40) {
            array_copy[i] = array[i];
            array_copy[i+1] = array[i+1];
            array_copy[i+2] = array[i+2];
            array_copy[i+3] = array[i+3];
            array_copy[i+4] = array[i+4];
            array_copy[i+5] = array[i+5];
            array_copy[i+6] = array[i+6];
            array_copy[i+7] = array[i+7];
            array_copy[i+8] = array[i+8];
            array_copy[i+9] = array[i+9];
            array_copy[i+10] = array[i+10];
            array_copy[i+11] = array[i+11];
            array_copy[i+12] = array[i+12];
            array_copy[i+13] = array[i+13];
            array_copy[i+14] = array[i+14];
            array_copy[i+15] = array[i+15];
            array_copy[i+16] = array[i+16];
            array_copy[i+17] = array[i+17];
            array_copy[i+18] = array[i+18];
            array_copy[i+19] = array[i+19];
            array_copy[i+20] = array[i+20];
            array_copy[i+21] = array[i+21];
            array_copy[i+22] = array[i+22];
            array_copy[i+23] = array[i+23];
            array_copy[i+24] = array[i+24];
            array_copy[i+25] = array[i+25];
            array_copy[i+26] = array[i+26];
            array_copy[i+27] = array[i+27];
            array_copy[i+28] = array[i+28];
            array_copy[i+29] = array[i+29];
            array_copy[i+30] = array[i+30];
            array_copy[i+31] = array[i+31];
            array_copy[i+32] = array[i+32];
            array_copy[i+33] = array[i+33];
            array_copy[i+34] = array[i+34];
            array_copy[i+35] = array[i+35];
            array_copy[i+36] = array[i+36];
            array_copy[i+37] = array[i+37];
            array_copy[i+38] = array[i+38];
            array_copy[i+39] = array[i+39];
    }

测试3-用步幅阅读。和用步幅复制一样。
跨步阅读：

    const int imax = 1000;
    for(int j = 0; j < imax; ++j) {
        uint64_t tmp = 0;
        performance = 0;
        time_start = glfwGetTime();
        for(uint64_t i = 0; i < ARRAY_NUM; i=i+40) {
                tmp = array[i];
                tmp = array[i+1];
                tmp = array[i+2];
                tmp = array[i+3];
                tmp = array[i+4];
                tmp = array[i+5];
                tmp = array[i+6];
                tmp = array[i+7];
                tmp = array[i+8];
                tmp = array[i+9];
                tmp = array[i+10];
                tmp = array[i+11];
                tmp = array[i+12];
                tmp = array[i+13];
                tmp = array[i+14];
                tmp = array[i+15];
                tmp = array[i+16];
                tmp = array[i+17];
                tmp = array[i+18];
                tmp = array[i+19];
                tmp = array[i+20];
                tmp = array[i+21];
                tmp = array[i+22];
                tmp = array[i+23];
                tmp = array[i+24];
                tmp = array[i+25];
                tmp = array[i+26];
                tmp = array[i+27];
                tmp = array[i+28];
                tmp = array[i+29];
                tmp = array[i+30];
                tmp = array[i+31];
                tmp = array[i+32];
                tmp = array[i+33];
                tmp = array[i+34];
                tmp = array[i+35];
                tmp = array[i+36];
                tmp = array[i+37];
                tmp = array[i+38];
                tmp = array[i+39];
        }

测试4-线性读数。字节/字节。我很惊讶这里没有结果。我以为是为了这些案子。
线性读数：

for(uint64_t i = 0; i < ARRAY_NUM; ++i) {
            tmp = array[i];
        }

测试5- 320 bytes作为对比。
备忘录：

memcpy(array_copy, array, ARRAY_NUM*sizeof(uint64_t));

结果
样品输出：
样品输出：

Init done in 0.767 s - size of array: 1024 MBs (x2)
Performance: 1304.325 MB/s

Copying (linear) done in 0.898 s
Performance: 1113.529 MB/s

Copying (stride 40) done in 0.257 s
Performance: 3890.608 MB/s

[1000/1000] Performance stride 40: 7474.322 MB/s
Average: 7523.427 MB/s
Performance MIN: 3231 MB/s | Performance MAX: 7818 MB/s

[1000/1000] Performance dumb: 2504.713 MB/s
Average: 2481.502 MB/s
Performance MIN: 1572 MB/s | Performance MAX: 2644 MB/s

Copying (memcpy) done in 1.726 s
Performance: 579.485 MB/s

--

Init done in 0.415 s - size of array: 512 MBs (x2)
Performance: 1233.136 MB/s

Copying (linear) done in 0.442 s
Performance: 1157.147 MB/s

Copying (stride 40) done in 0.116 s
Performance: 4399.606 MB/s

[1000/1000] Performance stride 40: 6527.004 MB/s
Average: 7166.458 MB/s
Performance MIN: 4359 MB/s | Performance MAX: 7787 MB/s

[1000/1000] Performance dumb: 2383.292 MB/s
Average: 2409.005 MB/s
Performance MIN: 1673 MB/s | Performance MAX: 2641 MB/s

Copying (memcpy) done in 0.102 s
Performance: 5026.476 MB/s

--

Init done in 0.228 s - size of array: 256 MBs (x2)
Performance: 1124.618 MB/s

Copying (linear) done in 0.242 s
Performance: 1057.916 MB/s

Copying (stride 40) done in 0.070 s
Performance: 3650.996 MB/s

[1000/1000] Performance stride 40: 7129.206 MB/s
Average: 7370.537 MB/s
Performance MIN: 4805 MB/s | Performance MAX: 7848 MB/s

[1000/1000] Performance dumb: 2456.129 MB/s
Average: 2435.556 MB/s
Performance MIN: 1496 MB/s | Performance MAX: 2637 MB/s

Copying (memcpy) done in 0.050 s
Performance: 5095.845 MB/s

-- 

Init done in 0.100 s - size of array: 128 MBs (x2)
Performance: 1277.200 MB/s

Copying (linear) done in 0.112 s
Performance: 1147.030 MB/s

Copying (stride 40) done in 0.029 s
Performance: 4424.513 MB/s

[1000/1000] Performance stride 40: 6497.635 MB/s
Average: 6714.540 MB/s
Performance MIN: 4206 MB/s | Performance MAX: 7843 MB/s

[1000/1000] Performance dumb: 2275.336 MB/s
Average: 2335.544 MB/s
Performance MIN: 1572 MB/s | Performance MAX: 2626 MB/s

Copying (memcpy) done in 0.025 s
Performance: 5086.502 MB/s

-- 

Init done in 0.051 s - size of array: 64 MBs (x2)
Performance: 1255.969 MB/s

Copying (linear) done in 0.058 s
Performance: 1104.282 MB/s

Copying (stride 40) done in 0.015 s
Performance: 4305.765 MB/s

[1000/1000] Performance stride 40: 7750.063 MB/s
Average: 7412.167 MB/s
Performance MIN: 3892 MB/s | Performance MAX: 7826 MB/s

[1000/1000] Performance dumb: 2610.136 MB/s
Average: 2577.313 MB/s
Performance MIN: 2126 MB/s | Performance MAX: 2652 MB/s

Copying (memcpy) done in 0.013 s
Performance: 4871.823 MB/s

-- 

Init done in 0.024 s - size of array: 32 MBs (x2)
Performance: 1306.738 MB/s

Copying (linear) done in 0.028 s
Performance: 1148.582 MB/s

Copying (stride 40) done in 0.008 s
Performance: 4265.907 MB/s

[1000/1000] Performance stride 40: 6181.040 MB/s
Average: 7124.592 MB/s
Performance MIN: 3480 MB/s | Performance MAX: 7777 MB/s

[1000/1000] Performance dumb: 2508.669 MB/s
Average: 2556.529 MB/s
Performance MIN: 1966 MB/s | Performance MAX: 2646 MB/s

Copying (memcpy) done in 0.007 s
Performance: 4617.860 MB/s

--

Init done in 0.013 s - size of array: 16 MBs (x2)
Performance: 1243.011 MB/s

Copying (linear) done in 0.014 s
Performance: 1139.362 MB/s

Copying (stride 40) done in 0.004 s
Performance: 4181.548 MB/s

[1000/1000] Performance stride 40: 6317.129 MB/s
Average: 7358.539 MB/s
Performance MIN: 5250 MB/s | Performance MAX: 7816 MB/s

[1000/1000] Performance dumb: 2529.707 MB/s
Average: 2525.783 MB/s
Performance MIN: 1823 MB/s | Performance MAX: 2634 MB/s

Copying (memcpy) done in 0.003 s
Performance: 5167.561 MB/s

--

Init done in 0.007 s - size of array: 8 MBs (x2)
Performance: 1186.019 MB/s

Copying (linear) done in 0.007 s
Performance: 1147.018 MB/s

Copying (stride 40) done in 0.002 s
Performance: 4157.658 MB/s

[1000/1000] Performance stride 40: 6958.839 MB/s
Average: 7097.742 MB/s
Performance MIN: 4278 MB/s | Performance MAX: 7499 MB/s

[1000/1000] Performance dumb: 2585.366 MB/s
Average: 2537.896 MB/s
Performance MIN: 2284 MB/s | Performance MAX: 2610 MB/s

Copying (memcpy) done in 0.002 s
Performance: 5059.164 MB/s

线性阅读比跨步阅读慢3倍。步幅读数在大约7500-7800 MB/s范围内最大。但有两件事让我困惑。在DDR31333MHz，最大内存吞吐量应该是 -fprefetch-loop-arrays那么为什么我没有达到它呢？为什么读取速度不一致，我如何优化（缓存未命中？）？从图表中更明显，尤其是线性读数，在性能上有规律的下降。
图
8-16 MB

32-64 MB

128-256 MB

512-1024 MB

全部在一起

以下是所有感兴趣的人的完整资料：

/*
gcc -pedantic -std=c99 -Wall -Werror -Wextra -Wno-unused -O0 -I "...path to glfw3 includes ..." -L "...path to glfw3 lib ..." arr_test_copy_gnuplot.c -o arr_test_copy_gnuplot -lglfw3 -framework OpenGL -framework Cocoa -framework IOKit -framework CoreVideo

optional: -fprefetch-loop-arrays
*/

#include <stdio.h>
#include <stdlib.h>
#include <string.h> /* memcpy */
#include <inttypes.h>
#include <GLFW/glfw3.h>

#define ARRAY_NUM 1000000 * 128 /* GIG */
int main(int argc, char *argv[]) {

    if(!glfwInit()) {
        exit(EXIT_FAILURE);
    }

    int cx = 0;
    char filename_stride[50];
    char filename_dumb[50];
    cx = snprintf(filename_stride, 50, "%lu_stride.dat", 
                    ((ARRAY_NUM*sizeof(uint64_t))/1000000));
    if(cx < 0 || cx >50) { exit(EXIT_FAILURE); }
    FILE *file_stride = fopen(filename_stride, "w");
    cx = snprintf(filename_dumb, 50, "%lu_dumb.dat", 
                    ((ARRAY_NUM*sizeof(uint64_t))/1000000));
    if(cx < 0 || cx >50) { exit(EXIT_FAILURE); }
    FILE *file_dumb   = fopen(filename_dumb, "w");
    if(file_stride == NULL || file_dumb == NULL) {
        perror("Error opening file.");
        exit(EXIT_FAILURE);
    }

    uint64_t *array = malloc(sizeof(uint64_t) * ARRAY_NUM);
    uint64_t *array_copy = malloc(sizeof(uint64_t) * ARRAY_NUM);

    double performance  = 0.0;
    double time_start   = 0.0;
    double time_end     = 0.0;
    double performance_min  = 0.0;
    double performance_max  = 0.0;

    /* Init array */
    time_start = glfwGetTime();
    for(uint64_t i = 0; i < ARRAY_NUM; ++i) {
        array[i] = 0xff;
    }
    time_end = glfwGetTime();

    performance = ((ARRAY_NUM * sizeof(uint64_t))/1000000) / (time_end - time_start);
    printf("Init done in %.3f s - size of array: %lu MBs (x2)\n", (time_end - time_start), (ARRAY_NUM*sizeof(uint64_t)/1000000));
    printf("Performance: %.3f MB/s\n\n", performance);

    /* Linear copy */
    performance = 0;
    time_start = glfwGetTime();
    for(uint64_t i = 0; i < ARRAY_NUM; ++i) {
        array_copy[i] = array[i];
    }
    time_end = glfwGetTime();

    performance = ((ARRAY_NUM * sizeof(uint64_t))/1000000) / (time_end - time_start);
    printf("Copying (linear) done in %.3f s\n", (time_end - time_start));
    printf("Performance: %.3f MB/s\n\n", performance);

    /* Copying with wide stride */
    performance = 0;
    time_start = glfwGetTime();
    for(uint64_t i = 0; i < ARRAY_NUM; i=i+40) {
            array_copy[i] = array[i];
            array_copy[i+1] = array[i+1];
            array_copy[i+2] = array[i+2];
            array_copy[i+3] = array[i+3];
            array_copy[i+4] = array[i+4];
            array_copy[i+5] = array[i+5];
            array_copy[i+6] = array[i+6];
            array_copy[i+7] = array[i+7];
            array_copy[i+8] = array[i+8];
            array_copy[i+9] = array[i+9];
            array_copy[i+10] = array[i+10];
            array_copy[i+11] = array[i+11];
            array_copy[i+12] = array[i+12];
            array_copy[i+13] = array[i+13];
            array_copy[i+14] = array[i+14];
            array_copy[i+15] = array[i+15];
            array_copy[i+16] = array[i+16];
            array_copy[i+17] = array[i+17];
            array_copy[i+18] = array[i+18];
            array_copy[i+19] = array[i+19];
            array_copy[i+20] = array[i+20];
            array_copy[i+21] = array[i+21];
            array_copy[i+22] = array[i+22];
            array_copy[i+23] = array[i+23];
            array_copy[i+24] = array[i+24];
            array_copy[i+25] = array[i+25];
            array_copy[i+26] = array[i+26];
            array_copy[i+27] = array[i+27];
            array_copy[i+28] = array[i+28];
            array_copy[i+29] = array[i+29];
            array_copy[i+30] = array[i+30];
            array_copy[i+31] = array[i+31];
            array_copy[i+32] = array[i+32];
            array_copy[i+33] = array[i+33];
            array_copy[i+34] = array[i+34];
            array_copy[i+35] = array[i+35];
            array_copy[i+36] = array[i+36];
            array_copy[i+37] = array[i+37];
            array_copy[i+38] = array[i+38];
            array_copy[i+39] = array[i+39];
    }
    time_end = glfwGetTime();

    performance = ((ARRAY_NUM * sizeof(uint64_t))/1000000) / (time_end - time_start);
    printf("Copying (stride 40) done in %.3f s\n", (time_end - time_start));
    printf("Performance: %.3f MB/s\n\n", performance);

    /* Reading with wide stride */
    const int imax = 1000;
    double performance_average = 0.0;
    for(int j = 0; j < imax; ++j) {
        uint64_t tmp = 0;
        performance = 0;
        time_start = glfwGetTime();
        for(uint64_t i = 0; i < ARRAY_NUM; i=i+40) {
                tmp = array[i];
                tmp = array[i+1];
                tmp = array[i+2];
                tmp = array[i+3];
                tmp = array[i+4];
                tmp = array[i+5];
                tmp = array[i+6];
                tmp = array[i+7];
                tmp = array[i+8];
                tmp = array[i+9];
                tmp = array[i+10];
                tmp = array[i+11];
                tmp = array[i+12];
                tmp = array[i+13];
                tmp = array[i+14];
                tmp = array[i+15];
                tmp = array[i+16];
                tmp = array[i+17];
                tmp = array[i+18];
                tmp = array[i+19];
                tmp = array[i+20];
                tmp = array[i+21];
                tmp = array[i+22];
                tmp = array[i+23];
                tmp = array[i+24];
                tmp = array[i+25];
                tmp = array[i+26];
                tmp = array[i+27];
                tmp = array[i+28];
                tmp = array[i+29];
                tmp = array[i+30];
                tmp = array[i+31];
                tmp = array[i+32];
                tmp = array[i+33];
                tmp = array[i+34];
                tmp = array[i+35];
                tmp = array[i+36];
                tmp = array[i+37];
                tmp = array[i+38];
                tmp = array[i+39];
        }
        time_end = glfwGetTime();

        performance = ((ARRAY_NUM * sizeof(uint64_t))/1000000) / (time_end - time_start);
        performance_average += performance;
        if(performance > performance_max) { performance_max = performance; }
        if(j == 0) { performance_min = performance; }
        if(performance < performance_min) { performance_min = performance; }

        printf("[%d/%d] Performance stride 40: %.3f MB/s\r", j+1, imax, performance);
        fprintf(file_stride, "%d\t%f\n", j, performance);
        fflush(file_stride);
        fflush(stdout);
    }
    performance_average = performance_average / imax;
    printf("\nAverage: %.3f MB/s\n", performance_average);
    printf("Performance MIN: %3.f MB/s | Performance MAX: %3.f MB/s\n\n", 
            performance_min, performance_max);

    /* Linear reading */
    performance_average = 0.0;
    performance_min     = 0.0;
    performance_max      = 0.0;
    for(int j = 0; j < imax; ++j) {
        uint64_t tmp = 0;
        performance = 0;
        time_start = glfwGetTime();
        for(uint64_t i = 0; i < ARRAY_NUM; ++i) {
            tmp = array[i];
        }
        time_end = glfwGetTime();

        performance = ((ARRAY_NUM * sizeof(uint64_t))/1000000) / (time_end - time_start);
        performance_average += performance;
        if(performance > performance_max) { performance_max = performance; }
        if(j == 0) { performance_min = performance; }
        if(performance < performance_min) { performance_min = performance; }
        printf("[%d/%d] Performance dumb: %.3f MB/s\r", j+1, imax, performance);
        fprintf(file_dumb, "%d\t%f\n", j, performance);
        fflush(file_dumb);
        fflush(stdout);
    }
    performance_average = performance_average / imax;
    printf("\nAverage: %.3f MB/s\n", performance_average);
    printf("Performance MIN: %3.f MB/s | Performance MAX: %3.f MB/s\n\n", 
            performance_min, performance_max);

    /* Memcpy */
    performance = 0;
    time_start = glfwGetTime();
    memcpy(array_copy, array, ARRAY_NUM*sizeof(uint64_t));
    time_end = glfwGetTime();

    performance = ((ARRAY_NUM * sizeof(uint64_t))/1000000) / (time_end - time_start);
    printf("Copying (memcpy) done in %.3f s\n", (time_end - time_start));
    printf("Performance: %.3f MB/s\n", performance);

    /* Cleanup and exit */
    free(array);
    free(array_copy);
    glfwTerminate();
    fclose(file_dumb);
    fclose(file_stride);

    exit(EXIT_SUCCESS);
}

总结
当使用线性访问是最常见模式的数组时，我应该如何编写具有最大和（接近）恒定速度的代码？
我可以从这个例子中了解到关于缓存和预取的什么？
这些图表告诉我一些我应该知道但我没有注意到的事情吗？
我还可以如何展开循环？我尝试过不显示任何结果，所以我采用了手动写入循环展开的方法。
多谢长篇大论。
编辑：
似乎 memcpy与不存在 10,664 MB/s标志时的性能不同！什么给予？缺少标志会产生更好的性能，如图中所示。

编辑2：
我终于用AVX达到了极限。

=== READING WITH AVX ===
[1000/1000] Performance AVX: 9868.912 MB/s
Average: 10029.085 MB/s
Performance MIN: 6554 MB/s | Performance MAX: 11464 MB/s

平均值接近10664。我不得不将编译器改为clang，因为gcc让我很难使用avx（-mavx）。这也是为什么图有更明显的下降。我仍然想知道如何/什么是/有不变的表现。我想这是由于缓存/缓存线。它还将解释在这里和那里高于DDR3速度的性能（最大为11464MB/s）。
对不起，我的gnuplot fu和它的钥匙。蓝色是SSE2（ -funroll-loops），橙色是AVX（ -O0）。紫色的步伐和以前一样，绿色的是愚蠢的阅读一次一个。

所以，最后两个问题是：
什么导致了下降以及如何保持更稳定的性能
有没有可能在没有内窥镜的情况下达到天花板？
最新版本的注册表： https://gist.github.com/Keyframe/1ed9062ec52fc4a0d14b
以及该版本的图表： http://imgur.com/a/cPeor

最佳答案

主存储器的峰值带宽的值为2倍。而不是10664 MB/s itshould be 21.3 GB/s（更准确地说应该是（21333_）MB/s-见下面我的推导）。事实上，您有时会看到超过10664MB/s，这应该告诉您在峰值带宽计算中可能存在问题。
为了获得最大带宽for Core2 through Sandy Bridge you need to use non-temporal stores。此外，you need multiple threads。您不需要AVX指令或展开循环。

void copy(char *x, char *y, int n)
{
    #pragma omp parallel for schedule(static)
    for(int i=0; i<n/16; i++)
    {
        _mm_stream_ps((float*)&y[16*i], _mm_load_ps((float*)&x[16*i]));
    }
}

数组需要16字节对齐，并且也是16的倍数。非暂时存储的经验法则是，当您复制的内存大于最后一级缓存的一半时，使用它们。在您的情况下，三级缓存大小的一半是1.5 MB，而您复制的最小数组是8 MB，因此这比上一级缓存大小的一半要大得多。
这里有一些代码来测试这个。

//gcc -O3 -fopenmp foo.c
#include <stdio.h>
#include <x86intrin.h>
#include <string.h>
#include <omp.h>

void copy(char *x, char *y, int n)
{
    #pragma omp parallel for schedule(static)
    for(int i=0; i<n/16; i++)
    {
        _mm_stream_ps((float*)&x[16*i], _mm_load_ps((float*)&y[16*i]));
    }
}

void copy2(char *x, char *y, int n)
{
    #pragma omp parallel for schedule(static)
    for(int i=0; i<n/16; i++)
    {
        _mm_store_ps((float*)&x[16*i], _mm_load_ps((float*)&y[16*i]));
    }
}

int main(void)
{
    unsigned n = 0x7fffffff;
    char *x = _mm_malloc(n, 16);
    char *y = _mm_malloc(n, 16);
    double dtime;

    memset(x,0,n);
    memset(y,1,n);

    dtime = -omp_get_wtime();
    copy(x,y,n);
    dtime += omp_get_wtime();
    printf("time %f\n", dtime);

    dtime = -omp_get_wtime();
    copy2(x,y,n);
    dtime += omp_get_wtime();
    printf("time %f\n", dtime);

    dtime = -omp_get_wtime();
    memcpy(x,y,n);
    dtime += omp_get_wtime();
    printf("time %f\n", dtime);  
}

在我的系统core2（nehalem之前）p9600@2.53GHz上，它给出

time non temporal store 0.39
time SSE store          1.10
time memcpy             0.98

复制2GB。
注意，你“触摸”你将要写的记忆是非常重要的（我用memset来做这个）。在访问内存之前，系统不一定要分配内存。如果在进行内存复制时内存没有被访问，那么执行此操作的开销会显著地影响结果。
According to wikipediaddr3-1333的内存时钟为166_MHz。DDR以两倍的内存时钟速率传输数据。此外，DDR3的总线时钟乘数为4。因此，DDR3的每个内存时钟的总乘法为8。另外，您的主板有两个内存通道。所以总的转移率是

 21333⅓ MB/s = (166⅔ 1E6 clocks/s) * (8 lines/clock/channel) * (2 channels) * (64-bits/line) * (byte/8-bits) * (MB/1E6 bytes).

关于c - 通过C中的预取和缓存优化对阵列的线性访问，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/33676991/

文章推荐： android - Firebase 的 ProGuard 规则是什么？

文章推荐： Android WifiManager.addNetwork() 返回 -1

文章推荐： android - 如何使用aapt2，文档在哪里？

文章推荐： android - 对 Android 中的请求代码值有什么建议吗？

opengl - 线性/非线性纹理映射扭曲的四边形
在我的 previous question ，已经确定，当纹理四边形时，面部被分解为三角形，纹理坐标以仿射方式插值。不幸的是，我不知道如何解决这个问题。 provided link很有用，但没有达到
Qt运动(线性)模糊
是否有简单的解决方案可以在 Qt 中为图像添加运动模糊？还没有找到任何关于模糊的好教程。我需要一些非常简单的东西，我可以理解，如果我可以改变模糊角度，那就太好了。最佳答案 Qt 没有运动模糊过滤器。
javascript - 线性+阈值统一尺度
我想构建一个有点复杂的轴，它可以处理线性数据到像素位置，直到某个值，在该值中所有内容都被归入一个类别，因此具有相同的数据到像素值。例如，考虑具有以下刻度线的 y 轴: 0%, 10%, 20%, 30
android - 线性、可滚动布局中的基线约束
我需要确保两个 View 元素彼此相邻且垂直高度相同。我会使用基线约束来做到这一点，但目前我正在使用线性、可滚动的布局( ScrollView 中的线性布局)，当我点击一个元素时，它不允许我从中获取基
regex - 如何在非贪婪的正则表达式中避免(线性)回溯？
考虑正则表达式 ".*?\s*$" 和一个不以空格结尾的字符串。示例 " a" .最后\s永远无法匹配 a这就是为什么匹配器迭代: \s\s\s\s\s - fails .\s\s\
approximation - 插值建议(线性，三次？)
Closed. This question needs to be more focused。它当前不接受答案。想要改善这个问题吗？更新问题，使它仅关注editing this post的一个问题。
assembly - 线性、物理、逻辑和虚拟内存地址有什么区别？
我正在尝试阅读英特尔软件开发人员手册以了解操作系统的工作原理，这四个寻址术语让我感到困惑。以上是我的理解，如有不对请指正。线性地址 : 对一个孤立的程序来说，似乎是一长串以地址0开头的内存。该程序的
javascript - 检查数字表达式(线性)是否有效？
有很多方法可以使用正则表达式并相应地使用匹配/测试匹配来检查字符串是否有效。我正在检查包含字母(a-b)、运算符(+、-、/、*)、仅特殊字符(如(')'、'(')和数字(0-9)的表达式是否有效我
r - 线性 SVM 和提取权重
我正在使用 iris 数据集在 R 中练习 SVM，我想从我的模型中获取特征权重/系数，但我想我可能误解了一些东西，因为我的输出给了我 32 个支持向量。假设我要分析四个变量，我会得到四个。我知道在使
r - 线性 SVM 和提取权重
我正在使用 iris 数据集在 R 中练习 SVM，我想从我的模型中获取特征权重/系数，但我想我可能误解了一些东西，因为我的输出给了我 32 个支持向量。假设我要分析四个变量，我会得到四个。我知道在使
java - 如何在android中滑动布局(线性/相对..)
如何向左或向右滑动线性布局。在该线性布局中，默认情况下我有一个不可见的删除按钮，还有一些其他小部件，它们都是可见状态，当向左滑动线性布局时，我需要使其可见的删除按钮，当向右滑动时，我需要隐藏该删除按钮
r - 线性 SVM 中的错误预测
我正在编写一个 R 脚本，运行时会给出因变量的预测值。我的所有变量都被分类(如图所示)并分配了一个编号，总类数为101。(每个类是歌曲名称)。所以我有一个训练数据集，其中包含 {(2,5,6,1)8
java - 线性 RGB 空间中的仿射变换
如果源栅格位于 linear RGB color space使用以下 Java 代码进行转换，应用过滤器时(最后一行)会引发 java.awt.image.ImagingOpException: Un
ios - UIVIew animateWithDuration 线性？
我想为我的多个 UIImageView 设置动画，使其从 A 点线性移动到 B 点。我正在使用 options:UIViewAnimationOptionCurveLinear - Apple 文档
css - 线性，右渐变到透明渐变，底部有额外渐变
我第一次无法使用 CSS3 创建好看的渐变效果。右侧应该有从黑色到透明的渐变透明渐变。底部是页脚，所以它需要在底部另外淡化为透明。如果可能的话，一个例子: 页面的背景是一张图片，所以不可能有非透明淡
c++ - 线性(超定)代数方程的解
我有一组线性代数方程，Ax=By。其中A是36x20的矩阵，x是20x1的 vector ，B是36x13，y是13x1。排名(A)=20。因为系统是超定的，所以最小二乘解是可能的，即； x = (
Python 将每月值插入每日值(线性): Pandas
我有一个带有年月数据列(yyyymm)的 Pandas 数据框。我计划将数据插入每日和每周值。下面是我的 df。 df: 201301 201302 201303
python - 线性 N 次等式问题的最小二乘法
假设我想找到2条任意高维直线的“交点”。这两条线实际上不会相交，但我仍然想找到最相交的点(即尽可能靠近所有线的点)。假设这些线有方向向量A、B和初始点C、D，我可以通过简单地设置一个线性最小二乘问题
java - 线性 "smoothed"函数使用查找表
如果我想编写一个函数(可能也是一个类)，它从不可变的查找表(调用构造函数时固定)返回线性“平滑”数据，如下所示: 例如func(5.0) == 0.5。存储查找表的最佳方式是什么？我正在考虑使用两
python - 线性 X 对数刻度
给定一条线 X像素长如: 0-------|---V---|-------|-------|-------max 如果0 <= V <= max , 线性刻度 V位置将是 X/max*V像素。如何计

IT王子

个人简介

我是一名优秀的程序员,十分优秀！

作者热门文章

滴滴打车优惠券免费领取

全站热门文章

首页

博学

6Ren·AI

商城

c - 通过C中的预取和缓存优化对阵列的线性访问