精华内容
下载资源
问答
  • CUDA内存拷贝

    千次阅读 2015-11-12 23:37:31
    1、cudaMemcpy() cudaMalloc() //线性内存拷贝 1 //线性内存拷贝 2 cudaMalloc((void**)&dev_A, data_size); 3 cudaMemcpy(dev_A, host_A, data_size, cudaMemcpyHostToDevice); 2、cudaMemcpy2D()...

    1、cudaMemcpy()<--> cudaMalloc()  //线性内存拷贝

    1 //线性内存拷贝
    2 cudaMalloc((void**)&dev_A, data_size);
    3 cudaMemcpy(dev_A, host_A, data_size, cudaMemcpyHostToDevice);

    2、cudaMemcpy2D()<-->cudaMallocPitch() //线性内存拷贝

    cudaError_t cudaMemcpy2D(    
        void *     dst,
        size_t     dpitch,
        const void *     src,
        size_t     spitch,
        size_t     width,
        size_t     height,
        enum cudaMemcpyKind     kind     
    )    

    例:

    1 cudaMallocPitch((void**)&devPtr, &pitch, width * sizeof(float), height); 
    2 cudaMemcpy2D( void* dst,size_t dpitch,const void* src,size_t spitch,size_t width,size_t height,enum cudaMemcpyKind kind )

    3、cudaMemcpy2DToArray()<-->cudaMallocArray() //(二维)线性内存到2维数组的拷贝

     1 cudaError_t cudaMemcpy2DToArray    (    
     2     struct cudaArray *     dst,
     3     size_t     wOffset,
     4     size_t     hOffset,
     5     const void *     src,
     6     size_t     spitch,
     7     size_t     width,
     8     size_t     height,
     9     enum cudaMemcpyKind     kind     
    10 )    

    例:

     1 void mv(float *y, float *A, float *x, int m, int n)
     2 {
     3     int blkNum = (m >> 4) + ((m & 15) ? 1 : 0); 
     4     int height = blkNum << 4;
     5     int width = (n & 255) ? (((n >> 8) + 1) << 8) : n;
     6     dim3 threads(16, 16);
     7     dim3 grid(blkNum, 1);
     8     cudaArray *d_A;
     9     float *d_x, *d_y;
    10 
    11     cudaChannelFormatDesc channelDesc = cudaCreateChannelDesc<float4>();
    12     cudaMallocArray(&d_A, &channelDesc, width >> 2, height);
    13     cudaMemcpy2DToArray(d_A, 0, 0, A, n * sizeof(float), n * sizeof(float), m, cudaMemcpyHostToDevice);
    14     cudaBindTextureToArray(texRefA, d_A);
    15     cudaMalloc((void **) &d_x, n * sizeof(float));
    16     cudaMalloc((void **) &d_y, m * sizeof(float));
    17 
    18     cudaMemcpy(d_x, x, n * sizeof(float), cudaMemcpyHostToDevice);
    19     mv_kernel<<< grid, threads >>>(d_y, d_A, d_x, m, n);
    20     cudaMemcpy(y, d_y, m * sizeof(float), cudaMemcpyDeviceToHost);
    21 
    22     cudaFree(d_y);
    23     cudaFree(d_x);
    24     cudaUnbindTexture(texRefA);
    25     cudaFreeArray(d_A);
    26 }

    4、cudaMemcpyToArray()<-->cudaMallocArray()  //(1维)线性内存到2维数组的拷贝

    1 cudaError_t cudaMemcpyToArray(    
    2     struct cudaArray *     dst,
    3     size_t     wOffset,
    4     size_t     hOffset,
    5     const void *     src,
    6     size_t     count,
    7     enum cudaMemcpyKind     kind     
    8 )    

    例:

     1 void initCudaTexture(float *h_volume, float2 *velocity)
     2 {
     3     cudaChannelFormatDesc desc = cudaCreateChannelDesc(32, 0, 0, 0, cudaChannelFormatKindFloat);
     4 
     5     cudaMallocArray(&d_volumeArray, &desc, 128, 128);
     6 
     7     cudaMemcpyToArray(d_volumeArray, 0, 0, h_volume, sizeof(float)*128*128, cudaMemcpyDeviceToDevice);
     8 
     9     tex.normalized = true;
    10     tex.filterMode = cudaFilterModeLinear;
    11     tex.addressMode[0] = cudaAddressModeWrap;
    12     tex.addressMode[1] = cudaAddressModeWrap;
    13     
    14     cutilSafeCall(cudaBindTextureToArray(tex, d_volumeArray));
    15 
    16 }

    5、cudaMemcpy3D()<-->cudaMalloc3DArray() //(1维)线性内存到3维数组的拷贝 

     1 cudaError_t cudaMemcpy3D(const struct cudaMemcpy3DParms *     p)     
     2 
     3 struct cudaExtent {
     4   size_t width;
     5   size_t height;
     6   size_t depth;
     7 };
     8 struct cudaExtent make_cudaExtent(size_t w, size_t h, size_t d);
     9 
    10 struct cudaPos {
    11   size_t x;
    12   size_t y;
    13   size_t z;
    14 };
    15 struct cudaPos make_cudaPos(size_t x, size_t y, size_t z);
    16 
    17 struct cudaMemcpy3DParms {
    18   struct cudaArray     *srcArray;
    19   struct cudaPos        srcPos;
    20   struct cudaPitchedPtr srcPtr;
    21   struct cudaArray     *dstArray;
    22   struct cudaPos        dstPos;
    23   struct cudaPitchedPtr dstPtr;
    24   struct cudaExtent     extent;
    25   enum cudaMemcpyKind   kind;
    26 };

     例: 

     1 void initCudaTexture(const uchar *h_volume, cudaExtent volumeSize)
     2 {
     3     cudaChannelFormatDesc channelDesc = cudaCreateChannelDesc<uchar>();
     4 
     5     cutilSafeCall(cudaMalloc3DArray(&d_volumeArray, &channelDesc, volumeSize));
     6 
     7     cudaMemcpy3DParms copyParams = {0};
     8     copyParams.srcPtr = make_cudaPitchedPtr((void*)h_volume, volumeSize.width*sizeof(uchar), volumeSize.width, volumeSize.height);
     9     copyParams.dstArray = d_volumeArray;
    10     copyParams.extent   = volumeSize;
    11     copyParams.kind     = cudaMemcpyHostToDevice;
    12     cutilSafeCall(cudaMemcpy3D(&copyParams));
    13 
    14     tex.normalized = true;
    15     tex.filterMode = cudaFilterModeLinear;
    16     tex.addressMode[0] = cudaAddressModeWrap;
    17     tex.addressMode[1] = cudaAddressModeWrap;
    18     tex.addressMode[2] = cudaAddressModeWrap;
    19 
    20     cutilSafeCall(cudaBindTextureToArray(tex, d_volumeArray, channelDesc));
    21 }

    6、cudaMemcpyToSymbol()  //拷贝到常数存储器

    1 __constant__ float constData[256];
    2 float data[256];
    3 cudaMemcpyToSymbol(constData, data, sizeof(data));
    4 cudaMemcpyFromSymbol(data, constData, sizeof(data));
    5 __device__ float devData; float value = 3.14f;
    6 cudaMemcpyToSymbol(devData, &value, sizeof(float));
    7 __device__ float* devPointer; float* ptr;
    8 cudaMalloc(&ptr, 256 * sizeof(float));
    9 cudaMemcpyToSymbol(devPointer, &ptr, sizeof(ptr));
    展开全文
  • 树:二叉树的内存拷贝和内存释放

    千次阅读 2018-02-21 22:49:18
    二叉树的内存拷贝算法 //拷贝二叉树 前序递归拷贝 void Copy_PreOrderTraverse(BiTree* dest,BiTree src) { if (NULL != src) { *dest = malloc(sizeof(BiTNode)); (*dest)->data = src->data;

    同样是利用递归思想进行拷贝和释放,大家把递归思想领悟就ok了

    二叉树的内存拷贝算法

    //拷贝二叉树 前序递归拷贝
    void Copy_PreOrderTraverse(BiTree* dest,BiTree src)
    {
    	if (NULL != src)
    	{
    		*dest = malloc(sizeof(BiTNode));
    		(*dest)->data = src->data;
    		Copy_PreOrderTraverse(&(*dest)->lchild,src->lchild);
    		Copy_PreOrderTraverse(&(*dest)->rchild,src->rchild);
    	}
    	else
    	{
    		*dest = NULL;
    	}
    }


    二叉树的内存释放算法

    //二叉树内存释放 前序递归释放内存
    void Free_PreOrderTraverse(BiTree tree)
    {
    	if (NULL != tree)
    	{
    		BiTree lchild = tree->lchild;
    		BiTree rchild = tree->rchild;
    		free(tree);
    		Free_PreOrderTraverse(lchild);
    		Free_PreOrderTraverse(rchild);
    	}
    }


    完整代码

    #define _CRT_SECURE_NO_WARNINGS
    #include <stdio.h>
    #include <stdlib.h>
    typedef char EleType;
    typedef struct BiTNode
    {
    	EleType data;//数据结点数据域
    	struct BiTNode	*lchild, *rchild;//左孩子,右孩子结点指针域
    }BiTNode,*BiTree;
    
    //约定通过前序遍历创建结点
    //每个结点都有左右孩子,孩子不存在为NULL
    void CreatBiTree(BiTree* tree)
    {
    	char c;
    	scanf("%c",&c);
    	if (' '== c)
    	{
    		*tree = NULL;
    	}
    	else
    	{
    		*tree = (BiTNode*)malloc(sizeof(BiTNode));
    		(*tree)->data = c;
    		CreatBiTree(&(*tree)->lchild);//创建左子树
    		CreatBiTree(&(*tree)->rchild);//创建右子树
    	}
    }
    void VisitNode(EleType data)
    {
    	printf("%c ", data);
    	return;
    }
    //前序遍历
    void PreOrderTraverse(BiTree tree)
    {
    	if (NULL != tree)
    	{
    		VisitNode(tree->data);
    		PreOrderTraverse(tree->lchild);
    		PreOrderTraverse(tree->rchild);
    	}
    }
    
    //拷贝二叉树 前序递归拷贝
    void Copy_PreOrderTraverse(BiTree* dest,BiTree src)
    {
    	if (NULL != src)
    	{
    		*dest = malloc(sizeof(BiTNode));
    		(*dest)->data = src->data;
    		Copy_PreOrderTraverse(&(*dest)->lchild,src->lchild);
    		Copy_PreOrderTraverse(&(*dest)->rchild,src->rchild);
    	}
    	else
    	{
    		*dest = NULL;
    	}
    }
    //二叉树内存释放 前序递归释放内存
    void Free_PreOrderTraverse(BiTree tree)
    {
    	if (NULL != tree)
    	{
    		BiTree lchild = tree->lchild;
    		BiTree rchild = tree->rchild;
    		free(tree);
    		Free_PreOrderTraverse(lchild);
    		Free_PreOrderTraverse(rchild);
    	}
    }
    
    int main(int argc, char *argv[])
    {
    	BiTree tree = NULL,newTree = NULL;
    	printf("请按前序遍历的方式输入结点数据,孩子结点为NULL用空格代替:");
    	CreatBiTree(&tree);
    	Copy_PreOrderTraverse(&newTree, tree);
    	printf("源二叉树的前序遍历:");
    	PreOrderTraverse(tree);
    	printf("\n新二叉树的前序遍历:");
    	PreOrderTraverse(newTree);
    	printf("\n");
    	//释放二叉树内存
    	Free_PreOrderTraverse(newTree);
    	return 0;
    }
    


    代码运行测试

    我们下图的二叉树进行测试。


    运行结果如下,注意:我们创建结点时的前序输入:ABC__D__EF__G__一个_表示一个空格哟


    展开全文
  • 字符串拷贝和内存拷贝函数

    千次阅读 2014-05-09 16:49:58
    字符串拷贝和内存拷贝函数:   strcpy(拷贝字符串)  定义函数:char *strcpy( char *dest, const char *src ); strcpy()函数只能拷贝字符串。strcpy()函数将源字符串 src 的每个字节拷贝到目的字符串 dest...

    字符串拷贝和内存拷贝函数:
     
    strcpy(拷贝字符串)  
    定义函数:char *strcpy( char *dest, const char *src );
    strcpy()函数只能拷贝字符串。strcpy()函数将源字符串 src 的每个字节拷贝到目的字符串 dest 中,src 字符串末尾的'\0'也被拷贝过去。strcpy()函数返回参数 dest 的起始地址。如果参数 dest 所指的内存空间不够大,可能会造成缓冲溢出(buffer Overflow)的错误情况(程序员必须保证目标字符数组的空间足够容纳需要复制的字符串。如果src 字符
    串比dest字符串长,多余的字符仍将被复制,它们将覆盖原先存储于dest数组后面的内存空间的值),在编写程序时请特别留意,或者用strncpy()来取代。如果参数 src 和 dst 在内存中出现重叠,其结果是未定义的。
     
    strncpy(拷贝字符串)  
    定义函数:char *strncpy( char *dest, const char *src, size_t n );
    strncpy()会将参数 src 字符串拷贝前 n 个字符至参数 dest 所指的地址。 函数返回参数 dest 的字符串起始地址。

    注意 n 的取值范围,不要超过 src 和 dest 的长度。
    #include<string.h>
    #include<stdio.h>
     
    int main()
    {
        char a1[30]="string(1)";
        char b1[]="STRING(2)";
        printf("before strcpy()  : %s\n", a1 );
        printf("after  strcpy()   : %s\n", strcpy( a1, b1 ) );
     
        char a2[30]="string(1)";
        char b2[]="STRING(2)";
            printf("before strncpy() : %s\n", a2 );
            printf("after    strncpy() : %s\n", strncpy( a2, b2, 6 ) );
    }  
     
    memcpy(拷贝内存内容)   

    定义函数:void * memcpy( void * dest, const void *src, size_t n ); memcpy()用来拷贝 src 所指的内存内容前 n 个字节到 dest所指的内存地址上。与 strcpy()不同的是,memcpy()会完整的复制 n 个字节,不会因为遇到字符串结束'\0'而结束。memcpy()函数可以拷贝任意类型的数据。memcpy()函数返回指向 dest 的指针。指针 src 和 dest 所指的内存区域不可重叠。在拷贝字符串时,通常都使用 strcpy()函数;在拷贝其它数据(例如结构)时,通常都使用 memcpy()函数。
     
    memmove(拷贝内存内容)  
    定义函数:void *memmove(void *dest, const void *src, size_t n );
    memmove()与 memc py()一样都是用来拷贝 src 所指的内存内容前 n 个字节到 dest 所指的地址上。不同的是,当src 和 dest 所指的内存区域重叠时,memmove()仍然可以正确的处理,不过执行效率上会比使用 memcpy()略慢些。该函数返回指向 dest 的指针。
    #include<string.h>
     
    int main()
    {
        char a[30]="string(1)";
        char b[]="string(2)";
            printf("before strcpy() :%s\n", a );
            printf("after strcpy() :%s\n", strcpy( a, b ) );
     
        a[30]="string(1)";
        b[]="string(2)";
            printf("before strncpy() : %s\n", a );
            printf("after strncpy() : %s\n", strncpy( a, b, 6 ) );

    memccpy(拷贝内存内容)  
    定义函数:void * memccpy( void *dest, const void *src, int c, size_t n );
    memccpy()用来拷贝 src 所指的内存内容前 n 个字节到 dest 所指的地址上。与 memcpy()不同的是,memccpy()会在复制时检查参数 c 是否出现,若是则返回 dest 中值为 c 的下一个字节地址。该函数返回指向 dest 中值为 c的下一个字节指针。返回值为 NULL 表示在 src 所指内存前 n 个字节中没有值为 c 的字节。 
     
    #include<string.h>
    #include<stdio.h>
     
    int main()
    {
        char a[]="string(a)";
        char b[]="string(b)";
        char *p;
        
            p = ( char * )memccpy( a, b, 'k', sizeof( b ) );
        
            if( p == NULL )
        {
            // 注意p 为NULL 的情况,这时不能读取p 所指的地方的内容 
                    printf("the return pointer of mymccpy is null !\n");
        }
        else
        {
                    printf("memccpy(): %s, *p = %c\n", a, *p );
        }

     
    bcopy (拷贝内存内容)  
    定义函数:void bcopy ( const void *src,void *dest ,int n); 
    bcopy()与 memcpy()一样都是用来拷贝 src 所指的内存内容前 n 个字节到 dest 所指的地址,不过参数 src 与 dest在传给函数时是相反的位置。建议使用 memcpy()取代 。

    展开全文
  • c++ memcpy内存拷贝

    千次阅读 2018-02-25 15:17:06
    memcpy指的是c和c++使用的内存拷贝函数,memcpy函数的功能是从源src所指的内存地址的起始位置开始拷贝n个字节到目标dest所指的内存地址的起始位置中 下面是游戏开发中的一个具体的应用: FR:徐海涛(hunk...
    void *memcpy(void *dest, const void *src, size_t n);


    解释:
    memcpy指的是c和c++使用的内存拷贝函数,memcpy函数的功能是从源src所指的内存地址的起始位置开始拷贝n个字节到目标dest所指的内存地址的起始位置中


    下面是游戏开发中的一个具体的应用:
    这里写图片描述



    FR:徐海涛(hunk Xu) QQ技术交流群:386476712

    展开全文
  • memcpy内存拷贝函数

    千次阅读 2017-08-01 15:01:56
    memcpy内存拷贝函数函数原型:void* memcpy(void *dest, void *src,size_t n);函数功能:是从src源所指的内存的起始地址开始拷贝size_t n个字节到目标dest所指的内存的起始地址。 用法:strcpy和memcpy的区别: ...
  • 结构体内存拷贝的两种方法

    千次阅读 2020-08-27 22:17:14
    结构体内存拷贝的两种方法
  • 内存拷贝优化(1)-小内存拷贝优化

    千次阅读 2011-03-14 21:42:00
    通过适当的编码技巧,让我们的内存拷贝速度超过memcpy两倍,是可以实现的。   有人说memcpy还能优化么?不就是rep movsd么?CPU和内存之间的带宽是固定的,怎么可能优化呢?其实是普通的内存拷贝并没有...
  • 内存拷贝函数的实现

    千次阅读 2016-06-11 14:05:26
    以前发表过关于字符串拷贝函数的实现和分析,那么为什么有了字符串拷贝函数,还需要内存拷贝函数? 一.关于内存拷贝函数的原型和实现。 原型: void *memmove( void *dest, const void *src, size_t count ); ...
  • 内存拷贝函数(C/C++)

    万次阅读 2018-06-14 22:44:32
    内存拷贝函数 编译环境与语言: Ubuntu 14.04 C/C++ 实现工业级的内存拷贝函数 内存拷贝代码 void* memcpy(void* dst, const void* src, int count) { assert((dst != NULL)&amp;&amp;(src != ...
  • 内存拷贝的注意事项

    千次阅读 2017-06-19 12:29:01
    有道面试题是让写出memcpy的实现,memcpy是c和c++使用的内存拷贝函数,功能是从源地址所指的内存地址的起始位置开始拷贝n个字节到目标地址所指的内存地址的起始位置中。与此类似的,在使用strcpy的时候,也应该需要...
  • 内存拷贝函数memcpy

    千次阅读 2014-04-13 15:32:02
    memcpy是C/C++内存拷贝函数,函数原型void*memcpy(void *dest, const void *src, size_t n);功能是从源src所指的内存地址的起始位置开始拷贝n个字节到目标dest所指的内存地址的起始位置中。 【memcpy与strcpy比较】...
  • C语言面试题---字符串拷贝函数与内存拷贝函数 看看下面的这题: strcpy()和memcpy()的区别? 答案: strcpy是字符串拷贝函数 memspy是内存拷贝函数 strcpy()和memcpy()都可以用来拷贝字符串,strcpy()拷贝以’\0’...
  • 内存拷贝和字符串拷贝

    千次阅读 2015-07-06 10:35:52
    1 先讨论下字符串拷贝,因为这个比较简单,但是还是有一些细节需要注意。我面试的时候就忘了写const //为了防止源字符串被修改,src应该为const char *strcpy(char *dst, const char *src); { //空指标检查 ...
  • 操作一般不会分配内存(在声明初始化时会分配),memcpy()函数的字面意思就是内存拷贝,把一块内存中的数据拷贝给另一块内存,这个过程中有新的内存分配了。     memcpy从名字上也可以理解出来是把内存拷贝,也...
  • 内存重叠:拷贝的目的地址在源地址范围内。所谓内存重叠就是拷贝的目的地址和源地址有重叠。在函数strcpy和函数memcpy都没有对内存重叠做处理的,使用这两个函数的时候只有程序员自己保证源地址和目标地址不重叠。...
  • 内存拷贝函数memcpy memcpy是memory copy的缩写,意为内存复制,在写C语言程序的时候,我们常常会用到它。它的函原型如下: void *memcpy(void *dest, const void *src, size_t n); 它的功能是从src的开始位置拷贝n...
  • 比memcpy更快的内存拷贝

    千次阅读 2013-05-11 18:51:11
    偶然间看到一个叫xmemcpy的工具,用做内存拷贝。号称在拷贝120字节以内时,比glibc提供的memcpy快10倍,并且有实验数据。  这让人感觉很诧异。一直以来都觉得memcpy是很高效的。相比于strcpy等函数的逐字节拷贝...
  • cuda 内存拷贝速率

    2019-08-21 15:20:28
    cuda 内存拷贝速率问题 `` CPU与GPU之间内存拷贝速率,一个9M的图片,CPU->GPU耗时9ms,GPU->CPU耗时11ms,项目要求处理的是大图,对每一个像素点做处理,以400M的图片为例子,cpu与gpu之间拷贝均耗时200多ms。...
  • 内存拷贝CopyMemory与MoveMemory

    千次阅读 2020-01-02 13:58:33
    CopyMemory是一个Windows API函数,它能将一块内存数据从一个位置复制到另一个位置; 函数原型: void CopyMemory( PVOID Destination, //要复制内存块的目的地址。 const VOID *Source, //要复制内存块的源地址...
  • C++常考面试题:实现内存拷贝函数

    千次阅读 2015-01-30 14:03:42
    C++常考面试题:实现内存拷贝函数
  • memcpy()内存拷贝和赋值操作效率测试

    千次阅读 2020-02-26 14:13:48
    比较memcpy()内存拷贝和"="赋值操作效率,测试代码如下 #include <stdio.h> #include <malloc.h> #include <windows.h> #define QueryFreAndCounter(m_fre,tt) QueryPerformanceFrequency(&m_...
  • 字符串转成byte数组,会发生内存拷贝吗? 怎么答 字符串转成切片,会产生拷贝。严格来说,只要是发生类型强转都会发生内存拷贝。那么问题来了。 频繁的内存拷贝操作听起来对性能不大友好。有没有什么办法可以在字符...
  • memcpy内存拷贝及优化策略图解

    千次阅读 2014-10-08 16:13:17
    #include using namespace std;...//不安全的内存拷贝(当源内存地址与目标内存地址重叠时会产生错误) void h_memcpy(void*src,void *dst,intsize){ if (src == NULL|| dst == NULL) { return; }
  • 【CUDA开发】CUDA面内存拷贝用法总结

    千次阅读 2017-01-26 23:29:20
    【CUDA开发】CUDA面内存拷贝用法总结标签(空格分隔): 【CUDA开发】主要是在调试CUDA硬解码并用D3D9或者D3D11显示的时候遇到了一些代码,如下所示:CUdeviceptr g_pRgba = 0; CUDA_MEMCPY2D memcpy2D = { 0 }; ...
  • Protocol Buffers 中实现ZeroCopyStream 来减少内存拷贝
  • 1、拷贝的数据是任意类型数据,所以指针用void * 接收。 2、src源数据一般是只读的,在函数内部对其修改是非法的。 3、返回值类型是void *,主要用来实现链式表达式,就像赋值表达式一样。 4、判断指针是否为NULL...
  • 异步调用之内存拷贝

    万次阅读 2020-01-19 09:39:14
    某次写一个库给前端调用,前端在传入一个分配的内存块给库里面有数据,然后库通过消息队列的方式将数据存储起来,发给服务端,但服务端收到的数据出现概率性乱码。 服务端打印收到的数据异常,客户端打印数据发现...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 564,602
精华内容 225,840
关键字:

内存拷贝