免费注册 查看新帖 |

Chinaunix

  平台 论坛 博客 文库
12下一页
最近访问板块 发新帖
查看: 6919 | 回复: 11

写了一段很丢人的代码,内存free不了,谁有BSD帮我测试一下. [复制链接]

论坛徽章:
0
发表于 2010-10-08 16:44 |显示全部楼层
本帖最后由 redor 于 2010-10-08 22:55 编辑

解压打开
  1. 执行命令 gcc -o mb memb.c -D_DEBUG_MEMB && ./mb
复制代码
然后top完按大M看一下内存占用......  linux下free不了内存. valgrind测试又没问题....... 郁闷....

大家有空在各自的BSD LINUX 等系统上帮我测试一下看看结果如何.
我重写了一遍代码不过还是有问题,总是不能free干净. 我把代码直接贴出来. 可以通过 gcc -o vmm mmblock.c -D_DEBUG_MMBLOCK  && ./vmm 直接运行.
mmblock.h

  1. #ifndef _MMBLOCK_H_
  2. #define _MMBLOCK_H_
  3. typedef struct _MMBLOCK
  4. {
  5.            char *data;
  6.            int  ndata;
  7.           int  size;
  8.         int  left;
  9.         char *end;
  10. }MMBLOCK;
  11. //#define  MMBLOCK_BASE         8192
  12. //#define  MMBLOCK_BASE         32768
  13. #define  MMBLOCK_BASE                 65536
  14. #define  MMBLOCK_MIN         1024
  15. #define  MMBLOCK_MAX         524288
  16. //#define  MMBLOCK_MAX         1048576
  17. /* initialize() */
  18. MMBLOCK *mmblock_init();
  19. /* recv() */
  20. int mmblock_recv(MMBLOCK *mmblock, int fd, int flag);
  21. /* read() */
  22. int mmblock_read(MMBLOCK *mmblock, int fd);
  23. /* SSL_read() */
  24. int mmblock_read_SSL(MMBLOCK *mmblock, void *ssl);
  25. /* push() */
  26. int mmblock_push(MMBLOCK *mmblock, char *data, int ndata);
  27. /* del() */
  28. int mmblock_del(MMBLOCK *mmblock, int ndata);
  29. /* reset() */
  30. void mmblock_reset(MMBLOCK *mmblock);
  31. /* clean() */
  32. void mmblock_clean(MMBLOCK *mmblock);
  33. #endif
复制代码
mmblock.c

  1. #include <stdlib.h>
  2. #include <string.h>

  3. #include "mmblock.h"
  4. /* initialize() */
  5. MMBLOCK *mmblock_init()
  6. {
  7.         MMBLOCK *mmblock = NULL;
  8.         return mmblock = (MMBLOCK *)calloc(1, sizeof(MMBLOCK));
  9. }

  10. /* incre() */
  11. int mmblock_incre(MMBLOCK *mmblock, int incre_size)
  12. {
  13.         int size = 0, n = 0;

  14.         if(mmblock && incre_size > 0)
  15.         {
  16.                 size = mmblock->ndata + incre_size;
  17.                 n = size / MMBLOCK_BASE;
  18.                 if(size % MMBLOCK_BASE) ++n;
  19.                 size = n * MMBLOCK_BASE;
  20.                 mmblock->data = (char *)realloc(mmblock->data, size);
  21.                 /*
  22.                 if(mmblock->data)
  23.                 {
  24.                         mmblock->data = (char *)realloc(mmblock->data, size);
  25.                 }
  26.                 else
  27.                 {
  28.                         mmblock->data = (char *)calloc(size, 1);
  29.                 }
  30.                 */
  31.                 if(mmblock->data)
  32.                 {
  33.                         mmblock->end = mmblock->data + mmblock->ndata;
  34.                         mmblock->left = size - mmblock->ndata;
  35.                         mmblock->size = size;
  36.                         return 0;
  37.                 }
  38.                 else
  39.                 {
  40.                         mmblock->end = mmblock->data = NULL;
  41.                         mmblock->left = mmblock->ndata = mmblock->size = 0;
  42.                 }
  43.                        
  44.         }
  45.         return -1;
  46. }

  47. /* check() */
  48. int mmblock_check(MMBLOCK *mmblock)
  49. {
  50.         if(mmblock && mmblock->left < MMBLOCK_MIN)
  51.         {
  52.                 return mmblock_incre(mmblock, MMBLOCK_BASE);               
  53.         }
  54.         return -1;
  55. }
  56. /* recv() */
  57. int mmblock_recv(MMBLOCK *mmblock, int fd, int flag)
  58. {
  59.         int n = -1;

  60.         if(mmblock && fd > 0)
  61.         {
  62.                 mmblock_check(mmblock);
  63.                 if(mmblock->data && mmblock->end && mmblock->left > 0
  64.                 && (n = recv(fd, mmblock->end, mmblock->left, flag)) > 0)
  65.                 {
  66.                         mmblock->end += n;
  67.                         mmblock->ndata += n;
  68.                         mmblock->left -= n;               
  69.                 }       
  70.         }
  71.         return n;
  72. }
  73. /* read() */
  74. int mmblock_read(MMBLOCK *mmblock, int fd)
  75. {
  76.         int n = -1;

  77.         if(mmblock && fd > 0)
  78.         {
  79.                 mmblock_check(mmblock);
  80.                 if(mmblock->data && mmblock->end && mmblock->left > 0
  81.                 && read(fd, mmblock->end, mmblock->left) > 0)
  82.                 {
  83.                         mmblock->ndata += n;
  84.                         mmblock->end += n;
  85.                         mmblock->left -= n;
  86.                 }
  87.         }
  88.         return n;
  89. }

  90. /* SSL_read() */
  91. int mmblock_read_SSL(MMBLOCK *mmblock, void *ssl)
  92. {
  93.         int n = -1;
  94.         return n;
  95. }

  96. /* push() */
  97. int mmblock_push(MMBLOCK *mmblock, char *data, int ndata)
  98. {
  99.         if(mmblock && data && ndata > 0)
  100.         {
  101.                 if(mmblock->left < ndata) mmblock_incre(mmblock, ndata);
  102.                 if(mmblock->left > ndata && mmblock->data && mmblock->end)
  103.                 {
  104.                         memcpy(mmblock->end, data, ndata);
  105.                         mmblock->ndata += ndata;
  106.                         mmblock->end += ndata;
  107.                         mmblock->left -= ndata;
  108.                         return ndata;
  109.                 }
  110.         }
  111.         return -1;
  112. }

  113. /* del() */
  114. int mmblock_del(MMBLOCK *mmblock, int ndata)
  115. {
  116.         char *s = NULL, *p = NULL;

  117.         if(mmblock && ndata > 0)
  118.         {
  119.                 if(mmblock->ndata <= ndata)
  120.                 {
  121.                         mmblock->end = mmblock->data;
  122.                         mmblock->left = mmblock->size;
  123.                         mmblock->ndata = 0;
  124.                 }
  125.                 else
  126.                 {
  127.                         p = mmblock->data;                       
  128.                         s = mmblock->data + ndata;
  129.                         while(s < mmblock->end) *p++ = *s++;
  130.                         mmblock->end = p;
  131.                         mmblock->left += ndata;
  132.                         mmblock->ndata -= ndata;
  133.                 }
  134.                 return 0;
  135.         }
  136.         return -1;
  137. }

  138. /* reset() */
  139. void mmblock_reset(MMBLOCK *mmblock)
  140. {
  141.         if(mmblock)
  142.         {
  143.                 if(mmblock->size > MMBLOCK_MAX)
  144.                 {
  145.                         if(mmblock->data) free(mmblock->data);
  146.                         mmblock->size = mmblock->ndata = mmblock->left = 0;
  147.                         mmblock->end = mmblock->data  = NULL;
  148.                 }
  149.                 else
  150.                 {
  151.                         mmblock->end = mmblock->data;
  152.                         mmblock->left = mmblock->size;
  153.                         mmblock->ndata = 0;
  154.                 }
  155.         }
  156.         return ;
  157. }

  158. /* clean() */
  159. void mmblock_clean(MMBLOCK *mmblock)
  160. {
  161.         if(mmblock)
  162.         {
  163.                 if(mmblock->data) free(mmblock->data);
  164.                 free(mmblock);
  165.         }
  166.         return ;
  167. }


  168. #ifdef _DEBUG_MMBLOCK
  169. int main()
  170. {
  171.         char *s = "DSKALFJLSDJFLKASJFKLDAJFKLAKLkljklajfldkfmnklasnfkladsnk";
  172.         MMBLOCK *mmblocks[20480];
  173.         int i = 0, n = strlen(s);
  174.         //initialize
  175.         for(i = 0; i < 20480; i++)
  176.         {
  177.                 if((mmblocks[i] = mmblock_init()))
  178.                 {
  179.                         mmblock_push(mmblocks[i], s, n);
  180.                 }
  181.         }
  182.         //clean
  183.         for(i = 0; i < 20480; i++)
  184.         {
  185.                 if(mmblocks[i]) mmblock_clean(mmblocks[i]);
  186.         }
  187.         while(1)sleep(1);
  188.         return 0;
  189. }
  190. #endif

复制代码

mmb.tar.gz

4.56 KB, 下载次数: 77

论坛徽章:
0
发表于 2010-10-08 22:21 |显示全部楼层
不知道Unix-Center上有没有BSD系统?很久没去了,以前在学校时倒经常在上面做代码测试。

论坛徽章:
1
CU十二周年纪念徽章
日期:2013-10-24 15:41:34
发表于 2010-10-08 22:44 |显示全部楼层
Unix-Center上有freebsd

论坛徽章:
0
发表于 2010-10-09 10:07 |显示全部楼层
估计是碎片的问题,malloc申请小内存,在释放时glibc不会将内存还给系统

论坛徽章:
0
发表于 2010-10-09 10:17 |显示全部楼层
是buffer起来了么?

论坛徽章:
0
发表于 2010-10-09 10:50 |显示全部楼层
估计是碎片的问题,malloc申请小内存,在释放时glibc不会将内存还给系统
cugb_cat 发表于 2010-10-09 10:07



    64K也算小内存? 很奇怪的问题.....

论坛徽章:
0
发表于 2010-10-09 10:59 |显示全部楼层
估计是碎片的问题,malloc申请小内存,在释放时glibc不会将内存还给系统
cugb_cat 发表于 2010-10-09 10:07



    好像还真是这个问题, 我把base设置为128k就没事了.........草.......

论坛徽章:
0
发表于 2010-10-09 11:34 |显示全部楼层
是buffer起来了么?
davelv 发表于 2010-10-09 10:17


不是是free完了 进程的实际占用内存不减.....

论坛徽章:
0
发表于 2010-10-09 11:37 |显示全部楼层
好像还真是这个问题, 我把base设置为128k就没事了.........草.......
redor 发表于 2010-10-09 10:59


有个函数可以设置使用sbk向系统申请内存的最大大小,超过这个大小用mmap,mmap的释放后可以马上还给系统。

论坛徽章:
0
发表于 2010-10-09 11:41 |显示全部楼层
glibc库里面有自己维护内存的方式,不一定是你free它就交给os去了。
您需要登录后才可以回帖 登录 | 注册

本版积分规则 发表回复

  

北京盛拓优讯信息技术有限公司. 版权所有 京ICP备16024965号-6 北京市公安局海淀分局网监中心备案编号:11010802020122 niuxiaotong@pcpop.com 17352615567
未成年举报专区
中国互联网协会会员  联系我们:huangweiwei@itpub.net
感谢所有关心和支持过ChinaUnix的朋友们 转载本站内容请注明原作者名及出处

清除 Cookies - ChinaUnix - Archiver - WAP - TOP