kernel 2.6.13 - space not freed to kernel
Quoting [email protected]:
Quoted 218 lines
i have a program that all it does is to allocate memory up until consume 1GB of
free resources. but when i delete it, it seemed that the space is not free to kernel, (notice this by looking at "top" or meminfo, as well as debug messages
prinf the memory info. using sysinfo (system call). this happens on mainline kernel 2.6.13 but not on other Redhat distros (RHEL3/RHEL4).so it seemed that on mainline 2.6.13, when the userprocess allocate mem and free
it mem, the freed memory is not returned back to the kernel... is this a possible bug????Please Observe this test program:
Assumption: inmain()the space (units in KB) to allocate is 1GB, if you machine
has less than that use lower space value- 100MB (to be left to avoid oom killer).
Idea: allocate using a linked list to as many nodes as it required to filled up
1GB or less of address spaceResult: on RHEL3 or 4, after the program allocate nodes, and then deallocate it,
sysinfo indicate the memory that were freed are returned to the kernel. on 2.6.13, after the proram allocate nodes, and then deallocate it, sysinfo give
the free{ram+swap} to be about the same as it was after the node finish allocating, seemed like the freed nodes address space were not returned to the
kernelany ideaS?
****************SOURCE CODE ********************************* #include <
stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <linux/sys.h>
#include <linux/kernel.h>
#include <sys/types.h>
#include <sys/sysinfo.h>//////////////////////// CONST DATA /////////////////////////////// #define LIMIT 102400 /* = 100MB (Units in KB) */ #define
KB_VALUE1024 /* Unit in bytes */
#defineARR_SIZE1024 /* array size for item data in node */ ////////////////////////////////////////////////////////////////////********************************************************************
* Node Data Structure for LLL
* size of this struct ~ 64 Bytes ********************************************************************/ struct node
{
int item[ARR_SIZE];
struct node * next;
};////////////////////////////// GLOBAL DATA //////////////////////////// struct node * head = NULL; /* head of LLL */
long unsignedcount_create= 0;
long unsigned count_destroy= 0; ////////////////////////////////////////////////////////////////////////**********************************************************************
* Add a Node to LLL; data Uninitialized
* Return: 1=succeed; 0=failed **********************************************************************/ intlll_add()
{
int i;
struct sysinfo si;struct node *tmp = (struct node *)malloc(sizeof(struct node)); if(tmp == NULL) {
sysinfo(&si);
printf("freeram (%lu), freeswap (%lu), totalram (%lu), totalswap
(%lu)\n",si.freeram * si.mem_unit / KB_VALUE, si.freeswap * si.mem_unit / KB_VALUE, si.totalram * si.mem_unit / KB_VALUE, si.totalswap * si.mem_unit / KB_VALUE); fprintf(stderr,"ERROR: FAILED MALLOC\n"); return 0; } else { /* Write data here so space got from malloc is reserved */ ++count_create; for(i = 0; i < ARR_SIZE; ++i) tmp->item[i] = 0; tmp->next= head; head = tmp; return 1; } }int
lll_destroy_all(){ struct node * tmp = head; while(tmp != NULL) { head = tmp->next; free(tmp); ++count_destroy; tmp = head; } return 1; }/**********************************************************************
* Allocating nodes according to the input space specified
* Assuming that input space is in KB, and free{ram+swap} > space + LIMIT (which is currently 100 MB) **********************************************************************/ intlll_eat(long unsigned space)
{
struct sysinfo si;
struct sysinfo si2;sysinfo(&si); sysinfo(&si2);while( ((si.freeram * si.mem_unit /
KB_VALUE) + (si.freeswap* si.mem_unit /KB_VALUE) - (si2.freeram* si2.mem_unit / KB_VALUE) - (si2.freeswap* si2.mem_unit / KB_VALUE)) <= (space)) { if(lll_add() <= 0) { perror("lll_add failed in lll_eat before done allocating specified space\n"); return 0; } sysinfo(&si2);}
sysinfo(&si2); printf("After Done lll_eat.... \n"); printf("BEFORE : freeram (%lu), freeswap (%lu), totalram (%lu), totalswap (%lu)\n", si.freeram * si.mem_unit / KB_VALUE, si.freeswap * si.mem_unit / KB_VALUE,si.totalram * si.mem_unit / KB_VALUE, si.totalswap * si.mem_unit / KB_VALUE); printf("AFTER : freeram (%lu), freeswap (%lu), totalram (%lu), totalswap (%lu)\n",si2.freeram * si2.mem_unit / KB_VALUE, si2.freeswap * si2.mem_unit / KB_VALUE, si2.totalram * si2.mem_unit / KB_VALUE, si2.totalswap * si2.mem_unit / KB_VALUE); return 1; }int
main(int argc, char ** argv)
{
int status;
int path;
pid_tspid;struct sysinfo si;
long unsigned space = 1048576; // alloc 1 GB (unit here in KB)///////////////////////////// DEBUGGING /////////////////////////////
sysinfo(&si);
printf("Before a.out parent (pid=%d) start.... \n",getpid()); printf("freeram (%lu), freeswap (%lu), totalram (%lu), totalswap (%lu)\n",
si.freeram * si.mem_unit /KB_VALUE,
si.freeswap * si.mem_unit /KB_VALUE,
si.totalram * si.mem_unit /KB_VALUE,
si.totalswap * si.mem_unit /KB_VALUE);
//////////////////////////////////////////////////////////////////////////if(!lll_eat(space)) { perror("Fail lll_eat\n"); exit(1); } printf("Done eating... Now Destroying\n"); sleep(5); lll_destroy_all(); printf("Done destroying...\n");printf("Created= %lu nodes, Destroyed= %lu nodes\n",
count_create,count_destroy);////////////////////////// DEBUGGING //////////////////////////////////
sysinfo(&si);
printf("After a.out parent exiting.... \n");
printf("freeram (%lu), freeswap (%lu), totalram (%lu), totalswap (%lu)\n",
si.freeram * si.mem_unit /KB_VALUE,
si.freeswap * si.mem_unit /KB_VALUE,
si.totalram * si.mem_unit /KB_VALUE,
si.totalswap * si.mem_unit /KB_VALUE);
////////////////////////////////////////////////////////////////////////return 0;
}