Performance (speed) Comparison of malloc, new, virtualalloc, and heapalloc

Here we compare the performance of C ++ Code Compiled by VC ++.

I used vc6.0 for testing.

I will not describe these usage cases.

 

I wrote a simple test code.

The test result is:

Malloc: 390
"New: 391"
Virtualalloc: 454
Heapalloc: 47

Obviously, heapalloc is the fastest allocation speed, followed by malloc. New is similar to malloc, and virtualalloc is the slowest (I told Xiaoqiang that it was the fastest in the past)

I tracked it.

New calls this code.

 

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. }

The malloc function is as follows:

1. _ Cribd void * _ cdecl malloc (
2. Size_t nsize
3. )
4. {
5. Return _ nh_malloc_dbg (nsize, _ newmode, _ normal_block, null, 0 );
6. }

Obviously, new and malloc eventually call the same _ nh_malloc_dbg, but new has an additional callback function call.

Continue and find that the final call is return heapalloc (_ crtheap, 0, size );

The truth is that

 

Virtualalloc cannot be tracked. If virtual memory is allocated, it may be slow.

Let's take a closer look at the book windows core programming!

Thank you! Welcome!

 

The test code is as follows:

1. /*************************************** ***************************
2. *
3. * Copyright (c) 2008, xxxx
4. * All Rights Reserved.
5. *
6. * File name: Main. cpp
7. * Abstract: test the memory application speed.
8. *
9. * Version: 1.0
10. * Author: Wu huiran
11. * Completion date:
12. *
13. * Replaced version:
14. * Original Author:
15. * Completion date:
16. *
17. **************************************** **************************/
19. # Include <iostream>
20. # Include <windows. h>
21. Using namespace STD;
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 );
37. }
38. Dwend =: gettickcount ();
39. Cout <"malloc 10000 times memory block size, time consumed" <dwend-dwstart <Endl;
40. Dw1 + = dwend-dwstart;
42. Dwstart =: gettickcount ();
43. For (I = 0; I <20000; I ++)
44. {
45. Char * pdest2 = new char [4096];
46. Delete pdest2;
48. }
49. Dwend =: gettickcount ();
50. Cout <"10000 new 4096 memory blocks, time consumed" <dwend-dwstart <Endl;
51. Dw2 + = dwend-dwstart;
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 times memory block size, time consumed" <dwend-dwstart <Endl;
61. Dw3 + = dwend-dwstart;
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 );
70. }
71. Dwend =: gettickcount ();
72. Cout <"heapalloc 10000 memory blocks per 4096 times, time consumed" <dwend-dwstart <Endl;
73. Dw4 + = dwend-dwstart;
75. }
77. Cout <"malloc:" <dw1 <Endl;
78. Cout <"New:" <dw2 <Endl;
79. Cout <"virtualalloc:" <dw3 <Endl;
80. Cout <"heapalloc:" <dw4 <Endl;
82. Return 0;
83. }