标签：int float C++ maxn 内存 ms 拷贝 include sizeof

#include<cstdio>
#include <cctype>
#include<cstdlib>
#include<cstring>
#include <time.h>


const int maxn = 1024 * 1024 * 1024 / 4;

struct Cons{
    int i,j,d;
    float w;
};

Cons *cons;
Cons *consCp;
int *Ci;
int *Cj;
int *Cd;
float *Cw;

int *CiCp;
int *CjCp;
int *CdCp;
float *CwCp;

void memcpyEach(){
    std::memcpy(CiCp,Ci,maxn * sizeof(int));
    std::memcpy(CjCp,Cj,maxn * sizeof(int));
    std::memcpy(CdCp,Cd,maxn * sizeof(int));
    std::memcpy(CwCp,Cw,maxn * sizeof(float));
}

void memcpyPage(){
    int *pdstCi = CiCp;
    int *psrcCi = Ci;
    int *pdstCj = CjCp;
    int *psrcCj = Cj;
    int *pdstCd = CdCp;
    int *psrcCd = Cd;
    float *pdstCw = CwCp;
    float *psrcCw = Cw;
    for(int i = 0;i<maxn * sizeof(int);i+=4096){
        std::memcpy(pdstCi,psrcCi,4096);
        std::memcpy(pdstCj,psrcCj,4096);
        std::memcpy(pdstCd,psrcCd,4096);
        std::memcpy(pdstCw,psrcCw,4096);
        pdstCi += 1024;
        psrcCi += 1024;
        pdstCj += 1024;
        psrcCj += 1024;
        pdstCd += 1024;
        psrcCd += 1024;
        pdstCw += 1024;
        psrcCw += 1024;
    }
}

void memcpyStruct(){
    std::memcpy(consCp,cons,maxn * sizeof(Cons));
}

void memcpyPageStruct(){
    Cons *pdstCons = consCp;
    Cons *psrcCons = cons;
    for(unsigned int i = 0;i< maxn;i+=4096 / sizeof(Cons)){
        std::memcpy(pdstCons,psrcCons,4096);
        pdstCons += 4096 / sizeof(Cons);
        psrcCons += 4096 / sizeof(Cons);
    }
}


void Malloc(){
    Ci = (int*)std::malloc(maxn * sizeof(int));
    Cj = (int*)std::malloc(maxn * sizeof(int));
    Cd = (int*)std::malloc(maxn * sizeof(int));
    Cw = (float*)std::malloc(maxn * sizeof(float));

    CiCp = (int*)std::malloc(maxn * sizeof(int));
    CjCp = (int*)std::malloc(maxn * sizeof(int));
    CdCp = (int*)std::malloc(maxn * sizeof(int));
    CwCp = (float*)std::malloc(maxn * sizeof(float));

    cons = (Cons*)std::malloc(maxn * sizeof(Cons));
    consCp = (Cons*)std::malloc(maxn * sizeof(Cons));
}

int main(){
    clock_t start,end;
    int timeuse;
    start =clock();
    Malloc();
    end = clock();
    timeuse = 1000 * (end - start) / CLOCKS_PER_SEC;
	printf("Malloc:%d ms\n", timeuse);

    start =clock();
    memcpyStruct();
    end = clock();
    timeuse = 1000 * (end - start) / CLOCKS_PER_SEC;
	printf("memcpyStruct:%d ms\n", timeuse);


    start =clock();
    memcpyEach();
    end = clock();
    timeuse = 1000 * (end - start) / CLOCKS_PER_SEC;
	printf("memcpyEach:%d ms\n", timeuse);

    start =clock();
    memcpyPage();
    end = clock();
    timeuse = 1000 * (end - start) / CLOCKS_PER_SEC;
	printf("memcpyPage:%d ms\n", timeuse);


    start =clock();
    memcpyPageStruct();
    end = clock();
    timeuse = 1000 * (end - start) / CLOCKS_PER_SEC;
	printf("memcpyPageStruct:%d ms\n", timeuse);
    return 0;
}

测试了在结构体下，以及分开存储。以及使用分页拷贝4KB的速度。结果显示，使用分页拷贝效率提高近10倍。
结果如下:

Malloc:0 ms
memcpyStruct:2115 ms
memcpyEach:2118 ms
memcpyPage:318 ms
memcpyPageStruct:293 ms

标签：int,float,C++,maxn,内存,ms,拷贝,include,sizeof
来源： https://www.cnblogs.com/fahaizhong/p/13724754.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。