内存分配_[转]内存分配malloc,new,heapalloc

这里比较的VC++编译的C++代码中的性能

我用的是VC6.0测试的

就不介绍这几个的用法了

我写了一段简单的测试代码

测试结果是：

malloc:390
new:391
VirtualAlloc:454
HeapAlloc:47

很明显的是HeapAlloc分配速度最快，malloc次之，new和malloc差不多，VirtualAlloc最慢了（以前小强跟我说这个最快）

我有跟踪了一下

new调用了这段代码

1. void * __cdecl _nh_malloc (


2.         size_t nSize,


3.         int nhFlag


4.          )


5. {


6.         return _nh_malloc_dbg(nSize, nhFlag, _NORMAL_BLOCK, NULL, 0);


7. }

malloc函数是这样的：

1. _CRTIMP void * __cdecl malloc (


2.         size_t nSize


3.          )


4. {


5.         return _nh_malloc_dbg(nSize, _newmode, _NORMAL_BLOCK, NULL, 0);


6. }


7.  

很明显，new和malloc最终调用相同的_nh_malloc_dbg，只是new多了一次函数调用

再继续跟下去，发现最终调用的是return HeapAlloc(_crtheap, 0, size);

基本上真相大白了

VirtualAlloc跟踪不进去，如果说分配的是虚拟内存的话，有可能会慢吧。

回头再认真看看《Windows核心编程》这本书！

欢迎指正！欢迎交流！

测试代码如下：

1. /******************************************************************


2. *


3. * Copyright (c) 2008, xxxx


4. * All rights reserved.


5. *


6. * 文件名称：main.cpp


7. * 摘    要： 测试申请内存的速度


8. *


9. * 当前版本：1.0


10. * 作     者：吴会然


11. * 完成日期：2008-11-30


12. *


13. * 取代版本：


14. * 原   作者：


15. * 完成日期：


16. *


17. ******************************************************************/


18.  


19. #include <iostream>


20. #include


21. using namespace std;


22.  


23. int main( int argc, char *argv[] )


24. {


25.     int i = 0;


26.     DWORD dw1 = 0, dw2 = 0, dw3 = 0, dw4 = 0;


27.     DWORD dwStart = 0;


28.     DWORD dwEnd = 0;


29.     for( int j = 0; j <10; j++ )


30.      {


31.          dwStart = ::GetTickCount();


32.         for( i = 0; i <20000; i++ )


33.          {


34.             char *pDest1 = (char *)malloc(4096);


35.              free( pDest1 );


36.     


37.          }


38.          dwEnd = ::GetTickCount();


39.          cout << "malloc 10000次4096大小的内存块，耗时" <
    
40.          dw1 += dwEnd - dwStart;


41.  


42.          dwStart = ::GetTickCount();


43.         for( i = 0; i <20000; i++ )


44.          {


45.             char *pDest2 = new char[4096];


46.             delete pDest2;


47.     


48.          }


49.          dwEnd = ::GetTickCount();


50.          cout << "new 10000次4096大小的内存块，耗时" <
    
51.          dw2 += dwEnd - dwStart;


52.  


53.          dwStart = ::GetTickCount();


54.         for( i = 0; i <20000; i++ )


55.          {


56.             void* pMem = ::VirtualAlloc(NULL, 4096,   MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE );


57.              ::VirtualFree(pMem, 0, MEM_RELEASE);


58.          }


59.          dwEnd = ::GetTickCount();


60.          cout << "VirtualAlloc 10000次4096大小的内存块，耗时" <
    
61.          dw3 += dwEnd - dwStart;


62.  


63.         HANDLE hHeap = ::HeapCreate(HEAP_NO_SERIALIZE, 0, 0);


64.          dwStart = ::GetTickCount();


65.         for( i = 0; i <20000; i++ )


66.          {


67.             void* pMem2 = ::HeapAlloc(hHeap, HEAP_NO_SERIALIZE, 4096 );


68.              ::HeapFree(hHeap, HEAP_NO_SERIALIZE, pMem2);


69.  


70.          }


71.          dwEnd = ::GetTickCount();


72.          cout << "HeapAlloc 10000次4096大小的内存块，耗时" <
    
73.          dw4 += dwEnd - dwStart;


74.  


75.      }


76.  


77.      cout << "malloc:" <
    
78.      cout << "new:" <
    
79.      cout << "VirtualAlloc:" <
    
80.      cout << "HeapAlloc:" <
    

====================================

转】李玮剑 评论
1 把分配的内存空间改为4M甚至更高（循环次数减少）试试，结果截然不同。处理M级的大文件时，用VirtualAlloc效率高

2 博主的测试需要考究，系统在创建线程时就已经预先在线程的堆栈段中提交了两个页面。 按照我的观点new和malloc只要消耗的内存没有超过页面大小就不会实际的进行存储器的保留与提交。二者的操作不在一个层面上。

3 在分配大于一个页面数据的时候 virtualAlloc才有意义

4 virtualAlloc是操作系统提供的最根本的内存分配接口。HeapAlloc预先使用virtualAlloc申请了大块的内存，并根据优化算法组织了用于内存管理的数据结构，主要是对小内存分配的优化 new和malloc是语言层面接口,由于HeapAlloc已经有了优化，所以vc中的malloc并没有使用更多的优化算法，直接转入 HeapAlloc。