• 内存池简单案例

            本章借助nginx源码中实现的内存池模块，将其抽离出来并实现一个简单的demo用于比较说明内存池的优点。内存池结构详细说明请见另一篇博文Nginx学习之内存管理。

            首先，将nginx源码中ngx_palloc.h、ngx_palloc.c、ngx_alloc.h、ngx_alloc.c四个文件拷贝出来，对其做一下简单修改，使其不再依赖nginx项目源码。

            ngx_alloc.h具体代码如下：

    1. /*
    2.  * Copyright (C) Igor Sysoev
    3.  * Copyright (C) Nginx, Inc.
    4.  */
    5.  
    6. #ifndef _NGX_ALLOC_H_INCLUDED_
    7. #define _NGX_ALLOC_H_INCLUDED_
    8.  
    9. #include 
    10. #include 
    11. #include 
    12. #include 
    13. #include 
    14.  
    15. #ifndef u_char
    16. #define u_char	unsigned char
    17. #endif
    18.  
    19. #ifndef ngx_uint_t
    20. #define	ngx_uint_t	 unsigned int
    21. #endif
    22.  
    23. #ifndef ngx_int_t
    24. #define ngx_int_t	int
    25. #endif
    26.  
    27. #ifndef ngx_inline
    28. #define ngx_inline      inline
    29. #endif
    30.  
    31. void *ngx_alloc(size_t size, void *log);
    32. void *ngx_calloc(size_t size, void *log);
    33.  
    34. #define ngx_free          free
    35.  
    36. #define ngx_memzero(buf, n)       (void) memset(buf, 0, n)
    37. #define ngx_memset(buf, c, n)     (void) memset(buf, c, n)
    38.  
    39.  
    40. /*
    41.  * Linux has memalign() or posix_memalign()
    42.  * Solaris has memalign()
    43.  * FreeBSD 7.0 has posix_memalign(), besides, early version's malloc()
    44.  * aligns allocations bigger than page size at the page boundary
    45.  */
    46.  
    47. #if (NGX_HAVE_POSIX_MEMALIGN || NGX_HAVE_MEMALIGN)
    48.  
    49. void *ngx_memalign(size_t alignment, size_t size, void *log);
    50.  
    51. #else
    52.  
    53. #define ngx_memalign(alignment, size, log)  ngx_alloc(size, log)
    54.  
    55. #endif
    56.  
    57.  
    58. extern ngx_uint_t  ngx_pagesize;
    59. extern ngx_uint_t  ngx_pagesize_shift;
    60. extern ngx_uint_t  ngx_cacheline_size;
    61.  
    62.  
    63. #endif /* _NGX_ALLOC_H_INCLUDED_ */

            ngx_alloc.c具体代码如下：

    1. /*
    2.  * Copyright (C) Igor Sysoev
    3.  * Copyright (C) Nginx, Inc.
    4.  */
    5.  
    6. #include "ngx_alloc.h"
    7.  
    8. ngx_uint_t  ngx_pagesize;
    9. ngx_uint_t  ngx_pagesize_shift;
    10. ngx_uint_t  ngx_cacheline_size;
    11.  
    12. void *
    13. ngx_alloc(size_t size, void *log)
    14. {
    15.     void  *p;
    16.  
    17.     p = malloc(size);
    18.     if (p == NULL) {
    19. 		printf("----------malloc(%u) failed---------\n", size);
    20.     }
    21.  
    22. 	// printf("----------malloc: %p:%u---------\n", p, size);
    23.     return p;
    24. }
    25.  
    26.  
    27. void *
    28. ngx_calloc(size_t size, void *log)
    29. {
    30.     void  *p;
    31.  
    32.     p = ngx_alloc(size, log);
    33.  
    34.     if (p) {
    35.         ngx_memzero(p, size);
    36.     }
    37.  
    38.     return p;
    39. }
    40.  
    41.  
    42. #if (NGX_HAVE_POSIX_MEMALIGN)
    43.  
    44. void *
    45. ngx_memalign(size_t alignment, size_t size, void *log)
    46. {
    47.     void  *p;
    48.     int    err;
    49.  
    50.     err = posix_memalign(&p, alignment, size);
    51.  
    52.     if (err) {
    53. 		printf("----------posix_memalign(%u, %u) failed---------\n", alignment, size);
    54.         p = NULL;
    55.     }
    56.  
    57. 	printf("----------posix_memalign: %p:%u @%u---------\n",  p, size, alignment);
    58.  
    59.     return p;
    60. }
    61.  
    62. #elif (NGX_HAVE_MEMALIGN)
    63.  
    64. void *
    65. ngx_memalign(size_t alignment, size_t size, void *log)
    66. {
    67.     void  *p;
    68.  
    69.     p = memalign(alignment, size);
    70.     if (p == NULL) {
    71. 		printf("----------memalign(%u, %u) failed---------\n", alignment, size);
    72.     }
    73.  
    74. 	printf("----------memalign: %p:%u @%u---------\n",  p, size, alignment);
    75.  
    76.     return p;
    77. }
    78.  
    79. #endif

            ngx_palloc.h具体代码如下：

    1. /*
    2.  * Copyright (C) Igor Sysoev
    3.  * Copyright (C) Nginx, Inc.
    4.  */
    5.  
    6. #ifndef _NGX_PALLOC_H_INCLUDED_
    7. #define _NGX_PALLOC_H_INCLUDED_
    8.  
    9. #include 
    10. #include 
    11. #include "ngx_alloc.h"
    12.  
    13. #define ngx_close_file           close
    14. #define ngx_close_file_n         "close()"
    15.  
    16. #define ngx_delete_file(name)    unlink((const char *) name)
    17. #define ngx_delete_file_n        "unlink()"
    18.  
    19. #define NGX_ENOENT        ENOENT
    20. #define ngx_errno         errno
    21.  
    22. #define  NGX_OK          0
    23. #define  NGX_ERROR      -1
    24. #define  NGX_AGAIN      -2
    25. #define  NGX_BUSY       -3
    26. #define  NGX_DONE       -4
    27. #define  NGX_DECLINED   -5
    28. #define  NGX_ABORT      -6
    29.  
    30. #define NGX_INVALID_FILE         -1
    31. #define NGX_FILE_ERROR           -1
    32.  
    33. typedef int               			ngx_err_t;
    34. typedef int                      	ngx_fd_t;
    35. typedef struct ngx_pool_s			ngx_pool_t;
    36. typedef struct ngx_chain_s			ngx_chain_t;
    37.  
    38. /*
    39.  * NGX_MAX_ALLOC_FROM_POOL should be (ngx_pagesize - 1), i.e. 4095 on x86.
    40.  * On Windows NT it decreases a number of locked pages in a kernel.
    41.  */
    42. #define NGX_MAX_ALLOC_FROM_POOL  (ngx_pagesize - 1)
    43.  
    44. #define NGX_DEFAULT_POOL_SIZE    (16 * 1024)
    45.  
    46. #define NGX_POOL_ALIGNMENT       16
    47. #define NGX_MIN_POOL_SIZE                                                     \
    48.     ngx_align((sizeof(ngx_pool_t) + 2 * sizeof(ngx_pool_large_t)),            \
    49.               NGX_POOL_ALIGNMENT)
    50.  
    51. #ifndef NGX_ALIGNMENT
    52. #define NGX_ALIGNMENT   sizeof(unsigned long)    /* platform word */
    53. #endif
    54.  
    55. #define ngx_align_ptr(p, a)                                                   \
    56.     (u_char *) (((uintptr_t) (p) + ((uintptr_t) a - 1)) & ~((uintptr_t) a - 1))
    57. 			  
    58. typedef void (*ngx_pool_cleanup_pt)(void *data);
    59.  
    60. typedef struct ngx_pool_cleanup_s  ngx_pool_cleanup_t;
    61.  
    62. struct ngx_pool_cleanup_s {
    63.     ngx_pool_cleanup_pt   handler;
    64.     void                 *data;
    65.     ngx_pool_cleanup_t   *next;
    66. };
    67.  
    68. typedef struct ngx_pool_large_s  ngx_pool_large_t;
    69.  
    70. struct ngx_pool_large_s {
    71.     ngx_pool_large_t     *next;
    72.     void                 *alloc;
    73. };
    74.  
    75. typedef struct {
    76.     u_char               *last;
    77.     u_char               *end;
    78.     ngx_pool_t           *next;
    79.     ngx_uint_t            failed;
    80. } ngx_pool_data_t;
    81.  
    82. struct ngx_pool_s {
    83.     ngx_pool_data_t       d;
    84.     size_t                max;
    85.     ngx_pool_t           *current;
    86.     ngx_chain_t          *chain;
    87.     ngx_pool_large_t     *large;
    88.     ngx_pool_cleanup_t   *cleanup;
    89.     void            *log;
    90. };
    91.  
    92. typedef struct {
    93.     ngx_fd_t              fd;
    94.     u_char               *name;
    95.     void            	 *log;
    96. } ngx_pool_cleanup_file_t;
    97.  
    98. ngx_pool_t *ngx_create_pool(size_t size, void *log);
    99. void ngx_destroy_pool(ngx_pool_t *pool);
    100. void ngx_reset_pool(ngx_pool_t *pool);
    101.  
    102. void *ngx_palloc(ngx_pool_t *pool, size_t size);
    103. void *ngx_pnalloc(ngx_pool_t *pool, size_t size);
    104. void *ngx_pcalloc(ngx_pool_t *pool, size_t size);
    105. void *ngx_pmemalign(ngx_pool_t *pool, size_t size, size_t alignment);
    106. ngx_int_t ngx_pfree(ngx_pool_t *pool, void *p);
    107.  
    108. ngx_pool_cleanup_t *ngx_pool_cleanup_add(ngx_pool_t *p, size_t size);
    109. void ngx_pool_run_cleanup_file(ngx_pool_t *p, ngx_fd_t fd);
    110. void ngx_pool_cleanup_file(void *data);
    111. void ngx_pool_delete_file(void *data);
    112.  
    113. #endif /* _NGX_PALLOC_H_INCLUDED_ */

            ngx_palloc.c具体代码如下：

    1. /*
    2.  * Copyright (C) Igor Sysoev
    3.  * Copyright (C) Nginx, Inc.
    4.  */
    5.  
    6. #include "ngx_palloc.h"
    7.  
    8. static ngx_inline void *ngx_palloc_small(ngx_pool_t *pool, size_t size,
    9.     ngx_uint_t align);
    10. static void *ngx_palloc_block(ngx_pool_t *pool, size_t size);
    11. static void *ngx_palloc_large(ngx_pool_t *pool, size_t size);
    12.  
    13. void ngx_pool_cleanup_file(void *data);
    14.  
    15. ngx_pool_t *
    16. ngx_create_pool(size_t size, void *log)
    17. {
    18.     ngx_pool_t  *p;
    19.  
    20.     p = ngx_memalign(NGX_POOL_ALIGNMENT, size, log);
    21.     if (p == NULL) {
    22.         return NULL;
    23.     }
    24.  
    25.     p->d.last = (u_char *) p + sizeof(ngx_pool_t);
    26.     p->d.end = (u_char *) p + size;
    27.     p->d.next = NULL;
    28.     p->d.failed = 0;
    29.  
    30.     size = size - sizeof(ngx_pool_t);
    31.  
    32. 	// 最多分1页内存大小
    33.     p->max = (size < NGX_MAX_ALLOC_FROM_POOL) ? size : NGX_MAX_ALLOC_FROM_POOL;
    34.  
    35.     p->current = p;
    36.     p->chain = NULL;
    37.     p->large = NULL;
    38.     p->cleanup = NULL;
    39.     p->log = log;
    40.  
    41.     return p;
    42. }
    43.  
    44. void
    45. ngx_destroy_pool(ngx_pool_t *pool)
    46. {
    47.     ngx_pool_t          *p, *n;
    48.     ngx_pool_large_t    *l;
    49.     ngx_pool_cleanup_t  *c;
    50.  
    51. 	// 清理资源一些必要操作
    52.     for (c = pool->cleanup; c; c = c->next) {
    53.         if (c->handler) {
    54.             printf("---------------c->handler(c->data)-----------------\n");
    55.             c->handler(c->data);
    56.         }
    57.     }
    58.  
    59. #if (NGX_DEBUG)
    60.  
    61.     /*
    62.      * we could allocate the pool->log from this pool
    63.      * so we cannot use this log while free()ing the pool
    64.      */
    65.  
    66.     for (l = pool->large; l; l = l->next) {
    67. 		printf("---------------free: %p-----------------\n", l->alloc);
    68.     }
    69.  
    70.     for (p = pool, n = pool->d.next; /* void */; p = n, n = n->d.next) {
    71. 		
    72. 		printf("---------------free: %p, unused: %u-----------------\n", p, p->d.end - p->d.last);
    73. 		
    74.         if (n == NULL) {
    75.             break;
    76.         }
    77.     }
    78.  
    79. #endif
    80.  
    81. 	// 释放大块内存
    82.     for (l = pool->large; l; l = l->next) {
    83.         if (l->alloc) {
    84.             ngx_free(l->alloc);
    85.         }
    86.     }
    87.  
    88. 	// 释放 pool 内存
    89.     for (p = pool, n = pool->d.next; /* void */; p = n, n = n->d.next) {
    90.         ngx_free(p);
    91.  
    92.         if (n == NULL) {
    93.             break;
    94.         }
    95.     }
    96. }
    97.  
    98. void
    99. ngx_reset_pool(ngx_pool_t *pool)
    100. {
    101.     ngx_pool_t        *p;
    102.     ngx_pool_large_t  *l;
    103.  
    104.     for (l = pool->large; l; l = l->next) {
    105.         if (l->alloc) {
    106.             ngx_free(l->alloc);
    107.         }
    108.     }
    109.  
    110.     for (p = pool; p; p = p->d.next) {
    111.         p->d.last = (u_char *) p + sizeof(ngx_pool_t);
    112.         p->d.failed = 0;
    113.     }
    114.  
    115.     pool->current = pool;
    116.     pool->chain = NULL;
    117.     pool->large = NULL;
    118. }
    119.  
    120. void *
    121. ngx_palloc(ngx_pool_t *pool, size_t size)
    122. {
    123. #if !(NGX_DEBUG_PALLOC)
    124.     if (size <= pool->max) {
    125.         return ngx_palloc_small(pool, size, 1);
    126.     }
    127. #endif
    128.  
    129.     return ngx_palloc_large(pool, size);
    130. }
    131.  
    132. void *
    133. ngx_pnalloc(ngx_pool_t *pool, size_t size)
    134. {
    135. #if !(NGX_DEBUG_PALLOC)
    136.     if (size <= pool->max) {
    137.         return ngx_palloc_small(pool, size, 0);
    138.     }
    139. #endif
    140.  
    141.     return ngx_palloc_large(pool, size);
    142. }
    143.  
    144. static ngx_inline void *
    145. ngx_palloc_small(ngx_pool_t *pool, size_t size, ngx_uint_t align)
    146. {
    147.     u_char      *m;
    148.     ngx_pool_t  *p;
    149.  
    150.     p = pool->current;
    151.  
    152.     do {
    153.         m = p->d.last;
    154.  
    155.         if (align) {
    156.             m = ngx_align_ptr(m, NGX_ALIGNMENT);
    157.         }
    158.  
    159. 		// 如果该 pool 结构中满足size大小的内存，则返回
    160.         if ((size_t) (p->d.end - m) >= size) {
    161.             p->d.last = m + size;
    162.  
    163.             return m;
    164.         }
    165.  
    166. 		// 指向pool链表的下一个pool结构
    167.         p = p->d.next;
    168.  
    169.     } while (p);
    170.  
    171. 	// 如果所有的pool链表中没有符合的内存块，则重新申请一个pool
    172.     return ngx_palloc_block(pool, size);
    173. }
    174.  
    175. static void *
    176. ngx_palloc_block(ngx_pool_t *pool, size_t size)
    177. {
    178.     u_char      *m;
    179.     size_t       psize;
    180.     ngx_pool_t  *p, *new;
    181.  
    182.     psize = (size_t) (pool->d.end - (u_char *) pool);
    183.  
    184.     m = ngx_memalign(NGX_POOL_ALIGNMENT, psize, pool->log);
    185.     if (m == NULL) {
    186.         return NULL;
    187.     }
    188.  
    189.     new = (ngx_pool_t *) m;
    190.  
    191.     new->d.end = m + psize;
    192.     new->d.next = NULL;
    193.     new->d.failed = 0;
    194.  
    195.     m += sizeof(ngx_pool_data_t);
    196.     m = ngx_align_ptr(m, NGX_ALIGNMENT);
    197.     new->d.last = m + size;
    198.  
    199.     for (p = pool->current; p->d.next; p = p->d.next) {
    200.         if (p->d.failed++ > 4) {
    201.             pool->current = p->d.next;
    202.         }
    203.     }
    204.  
    205.     p->d.next = new;
    206.  
    207.     return m;
    208. }
    209.  
    210. static void *
    211. ngx_palloc_large(ngx_pool_t *pool, size_t size)
    212. {
    213.     void              *p;
    214.     ngx_uint_t         n;
    215.     ngx_pool_large_t  *large;
    216.  
    217.     p = ngx_alloc(size, pool->log);
    218.     if (p == NULL) {
    219.         return NULL;
    220.     }
    221.  
    222.     n = 0;
    223.  
    224.     for (large = pool->large; large; large = large->next) {
    225.         if (large->alloc == NULL) {
    226.             large->alloc = p;
    227.             return p;
    228.         }
    229.  
    230.         if (n++ > 3) {
    231.             break;
    232.         }
    233.     }
    234.  
    235.     large = ngx_palloc_small(pool, sizeof(ngx_pool_large_t), 1);
    236.     if (large == NULL) {
    237.         ngx_free(p);
    238.         return NULL;
    239.     }
    240.  
    241.     large->alloc = p;
    242.     large->next = pool->large;
    243.     pool->large = large;
    244.  
    245.     return p;
    246. }
    247.  
    248. void *
    249. ngx_pmemalign(ngx_pool_t *pool, size_t size, size_t alignment)
    250. {
    251.     void              *p;
    252.     ngx_pool_large_t  *large;
    253.  
    254.     p = ngx_memalign(alignment, size, pool->log);
    255.     if (p == NULL) {
    256.         return NULL;
    257.     }
    258.  
    259.     large = ngx_palloc_small(pool, sizeof(ngx_pool_large_t), 1);
    260.     if (large == NULL) {
    261.         ngx_free(p);
    262.         return NULL;
    263.     }
    264.  
    265.     large->alloc = p;
    266.     large->next = pool->large;
    267.     pool->large = large;
    268.  
    269.     return p;
    270. }
    271.  
    272. ngx_int_t
    273. ngx_pfree(ngx_pool_t *pool, void *p)
    274. {
    275.     ngx_pool_large_t  *l;
    276.  
    277.     for (l = pool->large; l; l = l->next) {
    278.         if (p == l->alloc) {
    279. 			
    280. 			printf("---------------free: %p-----------------\n", l->alloc);
    281. 			
    282.             ngx_free(l->alloc);
    283.             l->alloc = NULL;
    284.  
    285.             return NGX_OK;
    286.         }
    287.     }
    288.  
    289.     return NGX_DECLINED;
    290. }
    291.  
    292. void *
    293. ngx_pcalloc(ngx_pool_t *pool, size_t size)
    294. {
    295.     void *p;
    296.  
    297.     p = ngx_palloc(pool, size);
    298.     if (p) {
    299.         ngx_memzero(p, size);
    300.     }
    301.  
    302.     return p;
    303. }
    304.  
    305. ngx_pool_cleanup_t *
    306. ngx_pool_cleanup_add(ngx_pool_t *p, size_t size)
    307. {
    308.     ngx_pool_cleanup_t  *c;
    309.  
    310.     c = ngx_palloc(p, sizeof(ngx_pool_cleanup_t));
    311.     if (c == NULL) {
    312.         return NULL;
    313.     }
    314.  
    315.     if (size) {
    316.         c->data = ngx_palloc(p, size);
    317.         if (c->data == NULL) {
    318.             return NULL;
    319.         }
    320.  
    321.     } else {
    322.         c->data = NULL;
    323.     }
    324.  
    325.     c->handler = NULL;
    326.     c->next = p->cleanup;
    327.  
    328.     p->cleanup = c;
    329.  
    330. 	printf("---------------add cleanup: %p-----------------\n", c);
    331.  
    332.     return c;
    333. }
    334.  
    335. void
    336. ngx_pool_run_cleanup_file(ngx_pool_t *p, ngx_fd_t fd)
    337. {
    338.     ngx_pool_cleanup_t       *c;
    339.     ngx_pool_cleanup_file_t  *cf;
    340.  
    341.     for (c = p->cleanup; c; c = c->next) {
    342.         if (c->handler == ngx_pool_cleanup_file) {
    343.  
    344.             cf = c->data;
    345.  
    346.             if (cf->fd == fd) {
    347.                 c->handler(cf);
    348.                 c->handler = NULL;
    349.                 return;
    350.             }
    351.         }
    352.     }
    353. }
    354.  
    355. void
    356. ngx_pool_cleanup_file(void *data)
    357. {
    358.     ngx_pool_cleanup_file_t  *c = data;
    359.  
    360. 	printf("----------file cleanup: fd:%d---------\n", c->fd);
    361.  
    362.     if (ngx_close_file(c->fd) == NGX_FILE_ERROR) {
    363. 		printf("----------\"%s\" failed---------\n", c->name);
    364.     }
    365. }
    366.  
    367. void
    368. ngx_pool_delete_file(void *data)
    369. {
    370.     ngx_pool_cleanup_file_t  *c = data;
    371.  
    372.     ngx_err_t  err;
    373.  
    374. 	printf("----------file cleanup: fd:%d %s---------\n", c->fd, c->name);
    375.  
    376.     if (ngx_delete_file(c->name) == NGX_FILE_ERROR) {
    377.         err = ngx_errno;
    378.  
    379.         if (err != NGX_ENOENT) {
    380. 			printf("----------\"%s\" failed---------\n",  c->name);
    381.         }
    382.     }
    383.  
    384.     if (ngx_close_file(c->fd) == NGX_FILE_ERROR) {
    385. 		printf("----------\"%s\" failed---------\n",  c->name);
    386.     }
    387. }

            测试主函数主要比较malloc/free申请内存及内存池申请的效率，main.c具体代码如下:

    1. /***********************************************
    2. *    Author : lijd
    3. *    Date   : 2022-11-30
    4. *	 Func   : 测试内存池功能主函数
    5. ***********************************************/
    6.  
    7. #include 
    8.  
    9. #include "ngx_palloc.h"
    10.  
    11. #define LOOP_NUM_1	(1024 * 400)
    12. #define LOOP_NUM_2	(1024)
    13. #define MEM_SIZE	16
    14.  
    15. #define MEM_POOL_SIZE (1024 * 4)
    16.  
    17. int main(int argc, char *const *argv)
    18. {
    19. 	int i, j;
    20. 	if(argc == 1)
    21. 	{
    22. 		printf("-----------------malloc/free---------------\n");
    23. 		
    24. 		for(i = 0; i < LOOP_NUM_1; i++)
    25. 		{
    26. 			for(j = 0; j < LOOP_NUM_2; j++)
    27. 			{
    28. 				void *p = malloc(MEM_SIZE);
    29. 			
    30. 				if(p == NULL)
    31. 				{
    32. 					printf("malloc error !\n");
    33. 					return -1;
    34. 				}
    35. 				memset(p, 0, MEM_SIZE);
    36. 				free(p);
    37. 			}
    38. 		}
    39. 	}
    40. 	else
    41. 	{
    42. 		printf("-----------------mem pool---------------\n");
    43. 		
    44. 		for(i = 0; i < LOOP_NUM_1; i++)
    45. 		{
    46. 			ngx_pool_t *pool = ngx_create_pool(MEM_POOL_SIZE, NULL);
    47. 			
    48. 			for(j = 0; j < LOOP_NUM_2; j++)
    49. 			{
    50. 				void *p = ngx_palloc(pool, MEM_SIZE);
    51. 				
    52. 				if(p == NULL)
    53. 				{
    54. 					printf("ngx_palloc error !\n");
    55. 					return -1;
    56. 				}
    57. 				memset(p, 0, MEM_SIZE);
    58. 			}
    59. 			
    60. 			ngx_destroy_pool(pool);
    61. 		}
    62. 	}
    63. 	
    64. 	return 0;
    65. }

            程序运行结果如下图：

  • 相关阅读:
    11 个 ES2022（ES13)中惊人的 JavaScript 新特性
    【Git】git多人共享协作添加成员并授权与git拉取或提交冲突解决
    SpringBoot自动配置原理解析 | 京东物流技术团队
    LeetCode简单题之和相等的子数组
    [Java] 浅析rpc的原理及所用到的基本底层技术
    Dom选择器
    EPLAN_A01#图框编辑
    数据结构与算法基础-(4)
    Qt： 利用QSplitter将主窗口与Docker窗口初始宽度比例2：1
    PerfView专题 (第一篇)：如何寻找 C# 热点函数
  • 原文地址：https://blog.csdn.net/ddazz0621/article/details/128110875