Nginx --- 内存分配

作者：hahaya
日期：2014-06-06

Nginx内存分配的源码主要位于${NGX_ROOT}/src/os/unix/ngx_alloc{.h|.c}文件中，Nginx提供ngx_alloc、ngx_calloc和ngx_memalign三个内存分配相关的函数，其中ngx_alloc和ngx_calloc是对系统malloc函数的封装，ngx_memalign在Linux系统下是对系统posix_memalign函数的封装，而在Solaris系统下是对系统memalign函数的封装，在其他系统下则是对ngx_alloc的define。既然Nginx提供了内存分配的函数，同样相应的也提供了内存释放的函数ngx_free，ngx_free仅仅是对系统函数free的define，因为malloc、posix_memalign、memalign分配的内存都是通过free函数释放的。

ngx_alloc.h

1. /*

2. * Copyright (C) Igor Sysoev

3. * Copyright (C) Nginx, Inc.

4. */

5. #ifndef _NGX_ALLOC_H_INCLUDED_

6. #define _NGX_ALLOC_H_INCLUDED_

7. #include <ngx_config.h>

8. #include <ngx_core.h>

9. void *ngx_alloc(size_t size, ngx_log_t *log); /* 分配内存 不进行初始化 */

10. void *ngx_calloc(size_t size, ngx_log_t *log); /* 分配内存 并自动初始化内存空间为0 */

11. #define ngx_free free /* 释放内存 */

12. /*

13. * Linux has memalign() or posix_memalign()

14. * Solaris has memalign()

15. * FreeBSD 7.0 has posix_memalign(), besides, early version's malloc()

16. * aligns allocations bigger than page size at the page boundary

17. */

18. /*

19. * 封装 posix_memalign，如果是 Solaris 则封装 memalign

20. * 根据当前电脑配置自动生成NGX_HAVE_MEMALIGN NGX_HAVE_POSIX_MEMALIGN宏

21. * 包含顺序为${NGX_ROOT}/src/core/ngx_config.h -> ${NGX_ROOT}/objs/ngx_auto_headers.h

22. * ngx_auto_headers.h中判断操作系统的相关类型等 根据不同的系统包含不同的系统头文件

23. * 测试机器为Linux 故接着通过ngx_config.h包含 ${NGX_ROOT}/src/os/unixngx_linux_config.h

24. * 接着包含${NGX_ROOT}/objs/ngx_auto_config.h

25. *

26. * note:ngx_auto_headers.h和ngx_auto_config.h文件是在配置Nginx过程中生成的(./configure过程)

27. */

28. #if (NGX_HAVE_POSIX_MEMALIGN || NGX_HAVE_MEMALIGN)

29. /*

30. * 内存分配对齐

31. */

32. void *ngx_memalign(size_t alignment, size_t size, ngx_log_t *log);

33. #else

34. /*

35. * 其他系统下，如果不存在内存分配对齐函数memalign()或posix_memalign 则直接使用ngx_alloc代替

36. */

37. #define ngx_memalign(alignment, size, log) ngx_alloc(size, log)

38. #endif

39. /*

40. * 声明三个外部使用的变量

41. * 全局变量ngx_alloc.c中定义 ${NGX_ROOT}/src/os/unix/ngx_posix_init.c中初始化

42. * 为了方便后面内存池等需要内存分配的地方使用而不用每次extern

43. * 即避免每个需要使用的文件中extern这三个变量 故放在ngx_malloc.h中

44. */

45. extern ngx_uint_t ngx_pagesize; /* 页大小 */

46. extern ngx_uint_t ngx_pagesize_shift; /* 页大小对应的移位数 */

47. extern ngx_uint_t ngx_cacheline_size; /* 缓存大小 */

48. #endif /* _NGX_ALLOC_H_INCLUDED_ */

ngx_alloc.c

3. /*

4. * Copyright (C) Igor Sysoev

5. * Copyright (C) Nginx, Inc.

6. */

7. #include <ngx_config.h>

8. #include <ngx_core.h>

9. /* 三个变量的定义 */

10. ngx_uint_t ngx_pagesize;

11. ngx_uint_t ngx_pagesize_shift;

12. ngx_uint_t ngx_cacheline_size;

13. /*

14. * 分配内存 主要是对系统函数malloc的封装

15. * 增加分配内存失败的判断机制 内存分配失败时写入日志文件

16. */

17. void *

18. ngx_alloc(size_t size, ngx_log_t *log)

19. {

20. void *p;

21. /* 调用malloc分配内存 */

22. p = malloc(size);

23. /* 分配内存失败 将错误信息写入日志文件 */

24. if (p == NULL) {

25. ngx_log_error(NGX_LOG_EMERG, log, ngx_errno,

26. "malloc(%uz) failed", size);

27. }

28. /* DEBUG模式下的处理 */

29. ngx_log_debug2(NGX_LOG_DEBUG_ALLOC, log, 0, "malloc: %p:%uz", p, size);

30. return p;

31. }

32. /*

33. * 分配内存 并将分配的内存初始化为0

34. * 封装ngx_alloc之后调用ngx_memzero初始化内存为0

35. */

36. void *

37. ngx_calloc(size_t size, ngx_log_t *log)

38. {

39. void *p;

40. //分配内存

41. p = ngx_alloc(size, log);

42. //内存初始化

43. if (p) {

44. ngx_memzero(p, size);

45. }

46. return p;

47. }

48. #if (NGX_HAVE_POSIX_MEMALIGN)

49. /*

50. * Linux系统下调用posix_memalign进行内存分配和内存对齐

51. *

52. */

53. void *

54. ngx_memalign(size_t alignment, size_t size, ngx_log_t *log)

55. {

56. void *p;

57. int err;

58. /*

59. * 背景：

60. * 1）POSIX 1003.1d

61. * 2）POSIX 标明了通过malloc( ), calloc( ), 和 realloc( ) 返回的地址对于任何的C类型来说都是对齐的

62. * 功能：由posix_memalign分配的内存空间，需要由free释放。

63. * 参数：

64. * p 分配好的内存空间的首地址

65. * alignment 对齐边界，Linux中，32位系统是8字节，64位系统是16字节

66. * size 指定分配size字节大小的内存

67. * 要求：

68. * 1）要求alignment是2的幂，并且是p指针大小的倍数

69. * 2）要求size是alignment的倍数

70. * 返回：

71. * 0 成功

72. * EINVAL 参数不满足要求

73. * ENOMEM 内存分配失败

74. * 注意：

75. * 1）该函数不影响errno，只能通过返回值判

76. * 2）在32位系统下malloc、calloc分配的内存是8字节为边界对齐的 即返回的内存地址起始值是8的倍数

77. * 3）在64位系统下malloc、calloc分配的内存时16字节为边界对齐的 即返回的内存地址起始值是16的倍数

78. * 4）有时候，对齐更大的边界，例如页面等，程序员需要动态的对齐，于是出现了posix_memalign函数

79. * 5）posix_memalign函数分配内存返回的内存地址起始值是alignment的倍数

80. */

81. err = posix_memalign(&p, alignment, size);

82. /* 内存分配失败 */

83. if (err) {

84. ngx_log_error(NGX_LOG_EMERG, log, err,

85. "posix_memalign(%uz, %uz) failed", alignment, size);:w

86. p = NULL;

87. }

88. ngx_log_debug3(NGX_LOG_DEBUG_ALLOC, log, 0,

89. "posix_memalign: %p:%uz @%uz", p, size, alignment);

90. return p;

91. }

92. #elif (NGX_HAVE_MEMALIGN)

93. /*

94. * Solaris系统下调用memalign进行内存分配和内存对齐

95. *

96. */

97. void *

98. ngx_memalign(size_t alignment, size_t size, ngx_log_t *log)

99. {

100. void *p;

101. p = memalign(alignment, size);

102. /* 内存分配失败 */

103. if (p == NULL) {

104. ngx_log_error(NGX_LOG_EMERG, log, ngx_errno,

105. "memalign(%uz, %uz) failed", alignment, size);

106. }

107. ngx_log_debug3(NGX_LOG_DEBUG_ALLOC, log, 0,

108. "memalign: %p:%uz @%uz", p, size, alignment);

109. return p;

110. }

111. #endif

为了方便测试和学习Nginx的内存分配，以免引入过多的文件，没有使用Nginx中的文件包含机制，去掉了出现分配错误后写入日志文件的操作，并且只关注Linux系统，测试代码如下：
ngx_alloc.h

2. #ifndef _NGX_ALLOC_H_INCLUDE_

3. #define _NGX_ALLOC_H_INCLUDE_

4. #include <stdio.h>

5. #include <stdlib.h>

6. #include <memory.h>

7. /* 分配内存 */

8. void *ngx_alloc(size_t size);

9. void *ngx_calloc(size_t size);

10. void *ngx_memalign(size_t alignment, size_t size);

11. /* 释放内存 */

12. #define ngx_free free

13. #endif

ngx_alloc.c

2. #include "ngx_alloc.h"

3. void *ngx_alloc(size_t size)

4. {

5. void *p;

6. p = malloc(size);

7. if (NULL == p) {

8. printf("malloc %d memory failed.\n", (int)size);

9. } else {

10. printf("malloc %d memory success.\n", (int)size);

11. }

12. return p;

13. }

14. void *ngx_calloc(size_t size)

15. {

16. void *p;

17. p = ngx_alloc(size);

18. if (p) {

19. memset(p, 0, size);

20. }

21. return p;

22. }

23. void *ngx_memalign(size_t alignment, size_t size)

24. {

25. void *p;

26. int err;

27. err = posix_memalign(&p, alignment, size);

28. if (err) {

29. printf("posix_memalign %d memory failed.\n", (int)size);

30. p = NULL;

31. } else {

32. printf("posix_memalign %d memory success.\n", (int)size);

33. }

34. return p;

35. }

ngx_alloc_test.c

2. #include "ngx_alloc.h"

3. int main()

4. {

5. //ngx_alloc

6. void *p_alloc = ngx_alloc(100);

7. printf("p_alloc address:%X\n", p_alloc);

8. ngx_free(p_alloc);

9. //ngx_calloc

10. char *p_calloc = (char*)ngx_calloc(100);

11. printf("p_calloc address:%X\n", p_calloc);

12. ngx_free(p_calloc);

13. //ngx_memalign

14. void *p_memalign = ngx_memalign(32, 1024);

15. printf("p_memalign address:%X\n", p_memalign);

16. ngx_free(p_memalign);

17. return 0;

18. }

makefile

2. cc = gcc

3. target = ngx_alloc_test

4. objs = ngx_alloc.o ngx_alloc_test.o

5. $(target):$(objs)

6. $(cc) $(objs) -o $(target)

7. ngx_alloc.o:ngx_alloc.h ngx_alloc.c

8. $(cc) -c -w ngx_alloc.c

9. ngx_alloc_test.o:ngx_alloc_test.c

10. $(cc) -c -w ngx_alloc_test.c

11. clean:

12. rm $(target) $(objs)

<<使用cJSON解析JSON数据