Free memory available functions

[johnmph]

Hello, i have coded little functions to know all memory available and maximum lineare memory available :

Header :

Code: Select all

#ifndef RAM_INCLUDED
#define RAM_INCLUDED

/* RAM simple check functions header */


// *** INCLUDES ***

#include <psptypes.h>
#include <malloc.h>


// *** DEFINES ***

#define RAM_BLOCK		&#40;1024 * 1024&#41;


// *** FUNCTIONS DECLARATIONS ***

u32 ramAvailableLineareMax &#40;void&#41;;
u32 ramAvailable &#40;void&#41;;

#endif

Source :

Code: Select all

/* RAM simple check functions source */


// *** INCLUDES ***

#include "ram.h"


// *** FUNCTIONS ***

u32 ramAavailableLineareMax (void)
{
 u32 size, sizeblock;
 u8 *ram;


 // Init variables
 size = 0;
 sizeblock = RAM_BLOCK;

 // Check loop
 while (sizeblock)
 {
  // Increment size
  size += sizeblock;

  // Allocate ram
  ram = malloc(size);

  // Check allocate
  if (!(ram))
  {
   // Restore old size
   size -= sizeblock;

   // Size block / 2
   sizeblock >>= 1;
  }
  else
   free(ram);
 }

 return size;
}

u32 ramAvailable (void)
{
 u8 **ram, **temp;
 u32 size, count, x;


 // Init variables
 ram = NULL;
 size = 0;
 count = 0;

 // Check loop
 for (;;)
 {
  // Check size entries
  if (!(count % 10))
  {
   // Allocate more entries if needed
   temp = realloc(ram,sizeof(u8 *) * (count + 10));
   if (!(temp)) break;
  
   // Update entries and size (size contains also size of entries)
   ram = temp;
   size += (sizeof(u8 *) * 10);
  }

  // Find max lineare size available
  x = ramAvailableLineareMax();
  if (!(x)) break;

  // Allocate ram
  ram[count] = malloc(x);
  if (!(ram[count])) break;

  // Update variables
  size += x;
  count++;
 }

 // Free ram
 if (ram)
 {
  for &#40;x=0;x<count;x++&#41; free&#40;ram&#91;x&#93;&#41;;
  free&#40;ram&#41;;
 &#125;

 return size;
&#125;

[AnonymousTipster]

I also coded one a week or so ago:
http://forums.ps2dev.org/viewtopic.php? ... t=ram+free
Which calculates to 0.1MB each time. Yours is more elegant, though.

[johnmph]

I also coded one a week or so ago:
http://forums.ps2dev.org/viewtopic.php? ... t=ram+free
Which calculates to 0.1MB each time. Yours is more elegant, though.

Thanks, yes it's similary.

I have coded a little sample for test it :

Code: Select all

int main (void)
{
 int x;
 u8 **ram;


 pspDebugScreenInit();
 pspDebugScreenClear();
 SetupCallbacks();


 printf("Memory available before : %d\n",ramAvailable());

 ram = malloc(100 * sizeof(u8 *));

 if (ram)
 {
  memset(ram,0,sizeof(u8 *) * 100);

  for &#40;x=0;x<100;x++&#41; ram&#91;x&#93; = malloc&#40;1000&#41;;

  printf&#40;"Memory available after malloc &#58; %d\n",ramAvailable&#40;&#41;&#41;;

  for &#40;x=0;x<100;x++&#41; if &#40;ram&#91;x&#93;&#41; free&#40;ram&#91;x&#93;&#41;;

  free&#40;ram&#41;;
 &#125;

 printf&#40;"Memory available after free &#58; %d\n",ramAvailable&#40;&#41;&#41;;

 printf&#40;"HOME for quit\n"&#41;;
 for &#40;;;&#41; sceDisplayWaitVblankStart&#40;&#41;;

 sceKernelExitGame&#40;&#41;;

 return 0;
&#125;

The program allocates 100 blocks of 1000 bytes (100000 bytes) + array of pointers to these blocks (100 * sizeof(U8 *) -> 100 * 4 = 400) = 100400 bytes.


When the program begins, it shows the free memory available before it allocates block :

23551384 bytes

and after block allocation :

23450176 bytes

but 23551384 - 100400 = 23450984 bytes

23450984 - 23450176 = 808 bytes

What is these 808 bytes ?, malloc structure informations ?, alignement of memory ??

[TyRaNiD]

Of course if you know your heap size (by using the PSP_HEAP_SIZE_KB macro) you can find the free space pretty easily.

Code: Select all

#include <malloc.h>

PSP_HEAP_SIZE_KB&#40;20*1024&#41;;

...

   struct mallinfo mi;

   mi = mallinfo&#40;&#41;;
   printf&#40;"freememory %dbytes\n", &#40;&#40;20*1024*1024&#41; - mi.arena + mi.fordblks&#41;;

Perhaps it would be a good idea to provide an accessor to get the ELF allocated heap size (which is as much memory as it can get) into newlib so you can do this sort of calculation trivially.

There does seem to be some wastage as you point out, probably for alignment and control structures I guess, not 100% sure without digging into the malloc routines ;) I also don't know how to easily determine the largest contiguous block available without doing something like you are doing.

[johnmph]

Of course if you know your heap size (by using the PSP_HEAP_SIZE_KB macro) you can find the free space pretty easily.

Code: Select all

#include <malloc.h>

PSP_HEAP_SIZE_KB&#40;20*1024&#41;;

...

   struct mallinfo mi;

   mi = mallinfo&#40;&#41;;
   printf&#40;"freememory %dbytes\n", &#40;&#40;20*1024*1024&#41; - mi.arena + mi.fordblks&#41;;

Perhaps it would be a good idea to provide an accessor to get the ELF allocated heap size (which is as much memory as it can get) into newlib so you can do this sort of calculation trivially.

There does seem to be some wastage as you point out, probably for alignment and control structures I guess, not 100% sure without digging into the malloc routines ;) I also don't know how to easily determine the largest contiguous block available without doing something like you are doing.

Thanks for mallinfo tricks ;-).

In fact, i have coded these functions to know if in my code, i didn't forget to free all memory.

But when i use a simple png load or save function, not all the memory is free (+- 400 bytes lost).

This is the save function, i have checked it and i don't found any errors :

Code: Select all

 // Open file
 fd = fopen(filename,"wb");
 if (!(fd)) return 2;

 // Create PNG write structure
 pngWrite = png_create_write_struct(PNG_LIBPNG_VER_STRING,NULL,NULL,NULL);
 if (!(pngWrite))
 {
  fclose(fd);

  return 3;
 }

 // Create PNG info structure
 pngInfo = png_create_info_struct(pngWrite);
 if (!(pngInfo))
 {
  png_destroy_write_struct(&pngWrite,png_infopp_NULL);
  fclose(fd);

  return 4;
 }

 // Write file
 png_init_io(pngWrite,fd);
 png_set_IHDR(pngWrite,pngInfo,image->width,image->height,8,PNG_COLOR_TYPE_RGB,PNG_INTERLACE_NONE,PNG_COMPRESSION_TYPE_DEFAULT,PNG_FILTER_TYPE_DEFAULT);
 png_write_info(pngWrite,pngInfo);

 // Allocate one line
 line = (u8 *) malloc(image->width * 3);
 if (!(line))
 {
  png_destroy_write_struct(&pngWrite,&pngInfo);
  fclose(fd);

  return 5;
 }

 // Initialize bmp pointer
 bmp = image->bmp;

 // Height loop
 for &#40;y=0;y<image->height;y++&#41; 
 &#123;
  // Width loop
  for &#40;x=0,x2=0;x<image->width;x++&#41;
  &#123;
   // Write pixel in line
   line&#91;x2++&#93; = GRAPHIC_GET_COLOR_R&#40;bmp&#91;x&#93;&#41;;
   line&#91;x2++&#93; = GRAPHIC_GET_COLOR_G&#40;bmp&#91;x&#93;&#41;;
   line&#91;x2++&#93; = GRAPHIC_GET_COLOR_B&#40;bmp&#91;x&#93;&#41;;
  &#125;

  // Write line
  png_write_row&#40;pngWrite,line&#41;;

  // Go to the next line
  bmp += image->widthA;
 &#125;

 // Free memory
 free&#40;line&#41;;
 png_write_end&#40;pngWrite,pngInfo&#41;;
 png_destroy_write_struct&#40;&pngWrite,&pngInfo&#41;;
 fclose&#40;fd&#41;;

 return 0;

It's possible that png functions doesn't free correctly memory ???

[johnmph]

With these functions, i have found some errors (forget to free memory) in my code, now the code is clean ;-) WITHOUT png functions.

I have coded a little bmp load function to test it and the program works and all memory is free but if i use png functions instead my bmp functions, there is always these bytes lost (+- 400).

I think seriously that png functions doesn't free all memory.

[johnmph]

I have found the function that cause the bytes lost, it's fopen.

When i use fopen and fclose, 384 bytes are lost, maybe it's normal, i don't know.

[jimparis]

How about just open() and close()? We allocate some mem in open() but it should get freed in close(). If the problem is just fopen/fclose, it's probably the internal buffering that newlib does; we didn't touch that code but it might be buggy.

[johnmph]

How about just open() and close()? We allocate some mem in open() but it should get freed in close(). If the problem is just fopen/fclose, it's probably the internal buffering that newlib does; we didn't touch that code but it might be buggy.

The problem is just fopen/fclose, if you write a little program like :

Code: Select all

FILE *f;

printf("ram available before : %d\n",ramAvailable());

f=fopen("ms0:/test.bin","rb");
if (f) fclose(f);

printf("ram available after : %d\n",ramAvailable());

The ram available after has 384 bytes less than before the fopen/fclose call even if the file is not opened (if the file doesn't exist).

[dot_blank]

has this been remedied yet

[PeterM]

Is it something that needs fixed? I'm quite happy for functions to maintain an internal buffer, as long as they don't leak each time they're called.

[Art]

Code: Select all

	printf("ESTIMATED FREE RAM: %d BYTES", ((20*1024*1024) - mi.arena + mi.fordblks); 

I'm not having the best time with it...
any idea why I get a syntax error in this line when I have included
include <malloc.h>
?

[Raphael]

You sure you also did include these lines:

PSP_HEAP_SIZE_KB(20*1024);

...

struct mallinfo mi;

mi = mallinfo();

They are crucial for this method to work.

[Art]

Doh, I think I put the bottom two lines inside the function.. which is probably wrong.

I *think* I have johnMPH's code working now... just got to use more
or less RAM to check it.
Cheers, Art.

[Art]

Although the function appears to work,
My program reports the same amount of available memory right down
to the exact byte whether it was started from IRshell or not.

IRshell must use some memory.. it hangs around because you can use
the note button to take a screenshot when your app is running.. so it must
be running somethng that uses RAM.

[AnonymousTipster]

Actually, iRShell resides almost entirely in kernel memory space and only breaks into user space with wifi and image viewing functions.
I think a better way to detect if running from a shell is to look at the psplink source to find what modules are running, and see if there are any more than usual.
You might want to ask Tyranid about this though, as the number may fluctuate, and I think it may also require a kernel mode application to work.

[Fanjita]

Actually, iRShell resides almost entirely in kernel memory space and only breaks into user space with wifi and image viewing functions.
I think a better way to detect if running from a shell is to look at the psplink source to find what modules are running, and see if there are any more than usual.
You might want to ask Tyranid about this though, as the number may fluctuate, and I think it may also require a kernel mode application to work.

You should be able to get sufficient info from the user-mode module info functions for these purposes, kernel isn't necessary.

[Art]

It even reports the same amount of memory,
if I start it from IRshell with an mp3 playing!

[siberianstar]

i wrote this in 2 seconds

Code: Select all

#include <malloc.h>
int __freemem&#40;&#41;
&#123;
 void *ptrs&#91;480&#93;;
 int mem, x, i;
 for &#40;x = 0; x < 480; x++&#41;
 &#123;
    void *ptr = malloc&#40;51200&#41;;
    if &#40;!ptr&#41; break;
 
    ptrs&#91;x&#93; = ptr;
 &#125;
 mem = x * 51200;
 for &#40;i = 0; i < x; i++&#41;
  free&#40;ptrs&#91;i&#93;&#41;;

 return mem;
&#125;

simple and fast

[flatmush]

Well I made quite a large post on psp-programming that is quite relevant to this topic, I hate to link to another forum but there seems little point in replicating the post here as it's quite large.
You will find a better free space function and lots of other memory related info here: http://www.psp-programming.com/forums/i ... pic=2731.0

Hate to bring up an old topic, but as it's a recurring question and this is the main thread for the answers to this question, I thought I'd post my algorithm.

This should be faster and more accurate than most the previous methods (except TyRaNiDs).

Code: Select all

#define MEMORY_USER_SIZE 0x01800000

u32 memFreeSpace(u32 inAccuracy) {
    if(!inAccuracy)
         inAccuracy = 1;

    u32 tempBlockSize = (MEMORY_USER_SIZE >> 1);
    u32 tempTests;
    
    for(tempTests = 0; tempBlockSize > inAccuracy; tempTests++)
         tempBlockSize >>= 1;
    tempBlockSize = (MEMORY_USER_SIZE >> 1);

    void* tempPointers[tempTests];
    
    u32 i; 
    u32 tempSpace = 0;
    for&#40;i = 0; i < tempTests; i++&#41; &#123;
         tempPointers&#91;i&#93; = malloc&#40;tempBlockSize&#41;;
         tempSpace += &#40;tempPointers&#91;i&#93; ? tempBlockSize &#58; 0&#41;;
         tempBlockSize >>= 1;
    &#125;
    
    for&#40;i = 0; i < tempTests; i++&#41; &#123;
         if&#40;tempPointers&#91;i&#93;&#41;
              free&#40;tempPointers&#91;i&#93;&#41;;
    &#125;
    
    return tempSpace;
&#125;

The inAccuracy parameter is how accurate you want the results to be, so 1 would give you the number of bytes, and 1024 would give the whole number of kilobytes etc.

EDIT: oops I feel stupid now, this will only work if your memory isn't fragmented at all, I'll have to think of a different approach (maybe recursive).