1
uint
memsize(void){ // Simply insert the memory size of the current process into size and return size
    uint size;
    struct proc *p;
    p = myproc();
    size = p->sz;
    
    return size;
}

// test_memsize.c
#define SIZE 2048

#include "types.h"
#include "user.h"

int main(void){
    int msize = memsize();
    printf("The process is using %dB\n", msize); // output: 12288B
    
    char *tmp = (char *)malloc(SIZE * sizeof(char)); 
    
    printf("Allocating more memory\n");
    msize = memsize();
    printf("The process is using %dB\n", msize); // output: 45045B
    
    free(tmp);
    printf("Freeing memory\n");
    msize = memsize();
    printf("The process is using %dB\n", msize); //output: 45045B
    
    exit();
}

The memory usage of the current process is 12288B and It was allocated as dynamic as 2048 bytes. But the result is 45045B. Why does this happen? (I'm using xv6.)

y J.
  • 131
  • 4
  • 3
    `free()` doesn't return memory to the OS, it just marks the memory as available for future `malloc()` calls. So the process memory size doesn't go down. – Barmar Sep 20 '22 at 17:21
  • 1
    45045 - 12288 = 32757 = 0x7FF5 or just under 32K. Looks like the OS or C library suballocator is handling dynamic memory in 32K pages. – Avi Berger Sep 20 '22 at 17:27
  • Someone — was it you? — asked [virtually the same question](https://stackoverflow.com/questions/73745119/why-is-the-allocated-memory-value-different#73745119) a few days ago, although it's since been deleted. If that was you, were the comments and suggestions there not helpful? – Steve Summit Sep 20 '22 at 19:57
  • Nope, it wasn't me. Was it the same code?? – y J. Sep 24 '22 at 06:40

1 Answers1

1

In the words of the C17 standard's description of the free() function, 7.22.3.3.2, (Emphasis mine):

"The free function causes the space pointed to by ptr to be deallocated, that is, made available for further allocation. If ptr is a null pointer, no action occurs. Otherwise, if the argument does not match a pointer earlier returned by a memory management function, or if the space has been deallocated by a call to free or realloc, the behavior is undefined."

Implementations of free() may choose to return the malloc/calloc-ated memory to the operating system when free() is called on its pointer, but they are not required to. This allows these implementations to keep that memory so that it may be reallocated in other malloc/calloc calls before the program terminates, preventing the overhead of returning and re-requesting memory pages from the operating system in programs that allocate and free memory often.

What is happening is your system's implementation of malloc/calloc/realloc/free is asking the operating system for a chunk of memory bigger than you asked for (most likely a page), and choosing to hold onto it after free in case you were to request more memory via malloc/calloc/realloc.

Willis Hershey
  • 1,520
  • 4
  • 22