[蓝森林-自由软件] - 动态内存_

#include "stdlib.h";
#include "unistd.h";

main()
{
char *p, *p1, *p2;
printf("pid=%d\n",getpid());
printf("sbrk=%x\n",p1=sbrk(0));
p = malloc(1024*1024*100);
printf("sbrk=%x\n",sbrk(0));
sleep(5);
free(p);
printf("sbrk=%x\n",sbrk(0));
sleep(5);
if (brk(p1) < 0) {
perror("brk");
exit(1);
}
printf("sbrk=%x\n",sbrk(0));
sleep(5);
}

haha, never mind, i'm just kidding. :)

How about I change it to this? Are you happy now?

在程序运行过程中, 使用 free 释放的动态内存一般是不会交还给系统的, 只能被
本程序后续的 *alloc 利用.

在程序结束后, 即使程序里没有使用 free 释放申请的动态内存, 所有属于该进程
内存自动回到系统的控制之下, 可以在以后分配给其它程序使用.

Excuse me, but i think your comments are just nifty picky. You knew we
were talking about malloc(3)/free(3)! Now you are not acting in the best
interest of answering the original question, rather trying to save face.
That's fine, i totally understand, after all we are human. I might do the
same thing. However i think you missed the point. The original question
is very common among programmers. To majority of them, malloc(3)/free(3)
are the bread and butter. They need to understand how it works from the
point of view of an application programmer, not a kernel hacker. What I
said above is not invented by me. It's the common knowledge in unix
programming circle for many years. It is the practical view of how the
thing works.

To most of us, saying "the system does not recycle memory, it just expires
the vm" is purely a nonsense. I feel sorry for the original poster who can
only get such a confusing and meaningless answer from this forum. To get
the record straight was my intention to post.

Of course the above cited common wisdom is not something carved on stone.
There are exceptions. At least one i'm aware of, linux. To be exactly it
is the glibc's implementation of malloc(3)/free(3) used in linux. In glibc,
if a chunk in the free list is bigger than a certain threshold, free(3) will
automatically return it to system.

And yes, your code using brk(2)/sbrk(2) indeed will be able to return memory
to the system. To show your point it's fine, but to use it this way in real
program is dangerous. The brk(2)/sbrk(2) are historical anyway. They probably
will eventually disappear or become deprecated.

If one really wants to be able to return memory to system, almost all modern
unix suggest to use mmap(2) to create a anonymous private mapping. When you
want to return the memory, do munmap(2).

However for an application programmer, he/she really does not need to know
all these details. It will be much better off for them just sticking with
malloc(3)/free(3) and leave the complexity of using mmap/munmap to library
programmers.

As for the vmstat problem. It says that you only have about 200MB left, and
you believed that is not possible. Either your vmstat was lying, or there's
something wired happening in your system. I'm just glad that it's not my
machine :) So good luck.