Release isn't working! The end of the world is here!

[Johanovski]

Repent, heretic! ^_^

Release is not doing what it's supposed to! I was happily working on my game when suddenly I've decided to watch how allocations are going on the device after making some changes at the images (avoiding .png image compression) and then, bang! The whole world crashed when I saw live memory is increasing as ever done. After seeking some explanation to the problem I've taken a memory printing function to see where exactly the problem is, and what a surprise when I saw that releasing functions are not freeing any space!

There are lot of images in the game so I've decided to load just the images that are going to be used and free useless images, then loading again when needed, etc.

I'm going to show you how all this works:

************************************************** ********
// First of all, the memory printing function:
- (void) print_free_memory {
mach_port_t host_port;
mach_msg_type_number_t host_size;
vm_size_t pagesize;

host_port = mach_host_self();
host_size = sizeof(vm_statistics_data_t) / sizeof(integer_t);
host_page_size(host_port, &pagesize);

vm_statistics_data_t vm_stat;

if (host_statistics(host_port, HOST_VM_INFO, (host_info_t)&vm_stat, &host_size) != KERN_SUCCESS)
NSLog(@"Failed to fetch vm statistics");

/* Stats in bytes */
natural_t mem_used = (vm_stat.active_count +
vm_stat.inactive_count +
vm_stat.wire_count) * pagesize;
natural_t mem_free = vm_stat.free_count * pagesize;
natural_t mem_total = mem_used + mem_free;
NSLog(@"used: %u free: %u total: %u", mem_used, mem_free, mem_total);
}
--------------------------------------------------------------------------------
// We're just starting a game and a function for loading textures is called:
- (void) carregaMosques
{
[self print_free_memory];

texMoscaNormal[0][0] = [[Image alloc] initWithImage:[UIImage imageWithContentsOfFile:[[NSBundle mainBundle] pathForResource:@"sangnormal01" ofType:@"png"]]];
texMoscaNormal[0][1] = [[Image alloc] initWithImage:[UIImage imageWithContentsOfFile:[[NSBundle mainBundle] pathForResource:@"sangnormal02" ofType:@"png"]]];
texMoscaNormal[0][2] = [[Image alloc] initWithImage:[UIImage imageWithContentsOfFile:[[NSBundle mainBundle] pathForResource:@"sangnormal03" ofType:@"png"]]];
texMoscaNormal[1][0] = [[Image alloc] initWithImage:[UIImage imageWithContentsOfFile:[[NSBundle mainBundle] pathForResource:@"gana" ofType:@"png"]]];
texMoscaNormal[1][1] = [[Image alloc] initWithImage:[UIImage imageWithContentsOfFile:[[NSBundle mainBundle] pathForResource:@"mnormalenrampa01" ofType:@"png"]]];
texMoscaNormal[1][2] = [[Image alloc] initWithImage:[UIImage imageWithContentsOfFile:[[NSBundle mainBundle] pathForResource:@"mnormalenrampa02" ofType:@"png"]]];
texMoscaNormal[2][0] = [[Image alloc] initWithImage:[UIImage imageWithContentsOfFile:[[NSBundle mainBundle] pathForResource:@"mnormal01" ofType:@"png"]]];
texMoscaNormal[2][1] = [[Image alloc] initWithImage:[UIImage imageWithContentsOfFile:[[NSBundle mainBundle] pathForResource:@"mnormal02" ofType:@"png"]]];
texMoscaNormal[2][2] = [[Image alloc] initWithImage:[UIImage imageWithContentsOfFile:[[NSBundle mainBundle] pathForResource:@"mnormal03" ofType:@"png"]]];

[self print_free_memory];
}
---------------------------------------------------------------------------
// Once the game is finished, a function for releasing loaded textures is called:
- (void) netejaMosques
{
[self print_free_memory];

[texMoscaNormal[0][0] release];
[texMoscaNormal[0][1] release];
[texMoscaNormal[0][2] release];
[texMoscaNormal[1][0] release];
[texMoscaNormal[1][1] release];
[texMoscaNormal[1][2] release];
[texMoscaNormal[2][0] release];
[texMoscaNormal[2][1] release];
[texMoscaNormal[2][2] release];

[self print_free_memory];
}
************************************************** *******

I've supposed that all the memory allocated in the first function is going to be released in the second function but, voilà! Memory increases when loading textures, but don't decreases when releasing textures! So, every time a game starts, same textures are loaded and it's memory space is NEVER freed (of course, there are much many functions that loads much many textures, but all of them are like this one, so it's the same case...).

What NSLog showed while tracing the game?

************************************************** *******
...[7868:207] Funcio CarregaMosques
...[7868:207] used: 2120642560 free: 2176602112 total: 2277376
...[7868:207] used: 2123165696 free: 2174124032 total: 2322432
(... some traces...)
...[7868:207] Funcio netejaMosques
...[7868:207] used: 2127245312 free: 2169683968 total: 1961984
...[7868:207] used: 2127245312 free: 2169704448 total: 1982464
************************************************** *******

So, as you can see, used memory increases when textures are loaded (of course), but used memory don't decreases when textures are released (eing?)!
I've also traced the textures retainCount and, as I've expected, retainCount just after calling release function is 1, so everything's OK...

What can be happening here? It have no sense! Is the end of the world here?

Any help you be madly appreciated! Thanks in advance!

[TunaNugget]

It's possible the Image class is doing some caching. I had a problem with images never being released in earlier versions of the OS, but that was with the ImageNamed method.

[scotopia]

Try tracing the retaincount of an object you are trying to release; its possible you are somehow retaining it one more time than you think you are and thus the release call won't actually free the object in memory.

[Oliver Drobnik]

Originally Posted by TunaNugget

It's possible the Image class is doing some caching. I had a problem with images never being released in earlier versions of the OS, but that was with the ImageNamed method.

output the retain count of the Image instances you are releasing. I bet that it's not 1 and thus the release does not put it to zero.

[Mr Jack]

Looks to me like the UIImage's you're creating and initialising the Image's which you are releasing with might not be being released.

[nobre84]

The retainCount after release is 1 ? It will only be dealloc'ed if it reaches 0.
What is the retainCount just after you place it in your array ?

Also, do you have a proper NSAutoreleasePool in place ? The [UIImage imageWith...] is autoreleased thus need one to release stuff.

[scotopia]

Originally Posted by Oliver Drobnik

output the retain count of the Image instances you are releasing. I bet that it's not 1 and thus the release does not put it to zero.

Lol; beat you to it

[scotopia]

Yeah; this is a common thing that is forgotten when you add an object to an array, for instance; the object is going to get retained again (above and beyond its original allocation).

[Johanovski]

Hi there!

I've checked array's (0,0) retainCount (which is an image) and it's 1 just before calling release. When trying to check after release an Exc bad acces is thrown (message sent to deallocated instance), so I've supposed release is correctly releasing the object (or maybe it just releases the array position? No idea of what is really doing, so it's not what I've thought since the beginning of the world...).
Something related to the array, you've said? Don't know why and what could be doing (or not doing)...
Any idea about this? I'm really at the edge of madness...

Thanks!

[Mr Jack]

Did you look at whether it's the UIImage hanging around as I suggested?

Try storing the UIImage's your using to initialise your Image's with in a different array and explicitly freeing them.

[Johanovski]

Hi Mr Jack!

I'm trying to do what you've said (or what I think you've said) but I'm not able to... If I'm not wrong (and I think I'm ^_^) what I have to do is to allocate each UIImage before initializing the Image class and then releasing the UIImage, right? So, it should be something like this:

************************************************** **************
UIImage* img = [[UIImage alloc] initWithContentsOfFile:[...]];

texMoscaNormal[0][0] = [[Image alloc] initWithImage:img];

[img release];
************************************************** **************

But it's not possible to allocate a UIImage (don't know why, but it's not possible), so I have no idea of what you're meaning... Sorry, I'm quite new to iPhone development and OpenGL...

Thanks!

[Mr Jack]

[UIImage initWithContentsOfFile:] creates and returns a UIImage. It is your responsiblity to clean up this returned UIImage.

The [UIImage alloc] is happening inside the initWithContentsOfFile: call which is a static member of UIImage so needs no object to be called on.

[Johanovski]

Hi Jack!

I thought method "imageWithContentsOfFile" didn't cache the image, so there's no need to release it... The returned image is needed to be allocated because it's being used every game's frame, so I can't release the Image class (the one is stored in the array) but, as I've explained, I thought the UIImage is never allocated, just created, returned, stored in the Image class as I've expected, and then destroyed (so a UIImage object is created, a Image object is then allocated and created from the UIImage returned object, and then no UIImage is stored)...
Does it works as I expect? If not (what I suppose), what I have to do to release the UIImage, if I have no object to call release (and no idea of how to autorelease an object, and even if it's possible)?

Thanks, and sorry for my newbie questions...

[Mr Jack]

Originally Posted by Johanovski

I thought method "imageWithContentsOfFile" didn't cache the image, so there's no need to release it...

Caching and needing to release are not the same thing.

[UIImage imageWithContentsOfFile] returns a UIImage*, this points to a UIImage object containing the image you requested. You need to release this yourself, to do this you just need to store the returned UIImage* and then call release on it when you are done with it. You do not need to call alloc because initWithContentsOfFile has already allocated the object.

Now, had you used imageNamed instead it would return a pointer to a UIImage object you would need to release and it would internally cache a copy of the image so that the next time you call ImageNamed it will load near instantly. That's what caching is.

...I thought the UIImage is never allocated, just created, returned, stored...

How did you expect it to be created without being allocated?

[Johanovski]

Hi again!

I think I understand what you mean, but still not knowing how to make it works... I've tried with the following code:

************************************************** ***
UIImage* img = [UIImage imageWithContentsOfFile:[[NSBundle mainBundle] pathForResource:@"sangnormal01" ofType:@"png"]];
texMoscaNormal[0][0] = [[Image alloc] initWithImage:img];
[img release];
************************************************** ***

So a UIImage* is created, the UIImage is allocated inside it's own method (so no additional alloc is called), then the Image class is initialized with a UIImage, and after this the UIImage* is released... I think this is the theory, more or less, but when I try to run the app...

----------------------------------------------------------------------
[1541:207] *** -[UIImage release]: message sent to deallocated instance 0x3b37a20
----------------------------------------------------------------------

Seems that log says UIImage is never allocated, so releasing is not possible... it's losing sense as time passes!

Thanks Jack!

[Mr Jack]

Hmm... I'm afraid I don't really know what else to suggest. I don't use initWithContentsOfFile.

[eddietr]

Originally Posted by Johanovski

UIImage* img = [UIImage imageWithContentsOfFile:[[NSBundle mainBundle] pathForResource:@"sangnormal01" ofType:@"png"]];
texMoscaNormal[0][0] = [[Image alloc] initWithImage:img];
[img release];  // <-- You don't want this

I haven't read the whole thread, but just commenting on this last post...

+[UIImage imageWithContentsOfFile] will return a UIImage that has been autoreleased.

So you don't want to release it again.

And then of course you want to make sure that -[Image initWithImage:] is retaining the UIImage and releasing it in -[Image dealloc].

Hope that helps.

[Johanovski]

Hi there!

Back from Christmas, and having to face the same (still unsolved) problem again... As it seems it have no sense that releasing images don't free memory at all, I've tried doing a test function to ensure that allocating and releasing variables is really affecting memory as it should do, so I've done the following:

************************************************** ***********
NSLog(@"Strings!");
[self print_free_memory];

NSString* things[400];

for (int i=0; i<400; i++) {
things[i] = [[NSString alloc] initWithString:@"Yabadabadoo!"];
}

[self print_free_memory];

for (int i=0; i<400; i++) {
[things[i] release];
}

[self print_free_memory];
************************************************** ***********

And what I get in the console, running in the 3.1.2 OS simulator in debug mode is:

************************************************** ***********
...[710:207] Strings!
...[710:207] used: 1547698176 free: 2749194240 total: 1925120
...[710:207] used: 1547710464 free: 2749214720 total: 1957888
...[710:207] used: 1547722752 free: 2749235200 total: 1990656
************************************************** ***********

What the #%&"?? Seems that used memory don't decrease even when I release 400 allocated NSStrings? Does it really have sense...?

Thanks, any help will be really appreciated!

[Johanovski]

Sorry, I've forget copying the print_free_memory function too:

************************************************** ************
- (void) print_free_memory {
mach_port_t host_port;
mach_msg_type_number_t host_size;
vm_size_t pagesize;

host_port = mach_host_self();
host_size = sizeof(vm_statistics_data_t) / sizeof(integer_t);
host_page_size(host_port, &pagesize);

vm_statistics_data_t vm_stat;

if (host_statistics(host_port, HOST_VM_INFO, (host_info_t)&vm_stat, &host_size) != KERN_SUCCESS)
NSLog(@"Failed to fetch vm statistics");

/* Stats in bytes */
natural_t mem_used = (vm_stat.active_count +
vm_stat.inactive_count +
vm_stat.wire_count) * pagesize;
natural_t mem_free = vm_stat.free_count * pagesize;
natural_t mem_total = mem_used + mem_free;
NSLog(@"used: %u free: %u total: %u", mem_used, mem_free, mem_total);
}
************************************************** ************

Thanks!

[smasher]

Originally Posted by Johanovski

What the #%&"?? Seems that used memory don't decrease even when I release 400 allocated NSStrings? Does it really have sense...?

Thanks, any help will be really appreciated!

Change that to mutableStrings and you'll probably get the results you're expecting. [[NSString alloc] initWithString:@"Yabadabadoo!"] will have the same result as just writing @"Yabadabadoo!" , which is a static string that doesn't get deallocated at all during the life of your program.

RE: your images releasing, I think someone pointed out in another thread that your Texture2D dealloc call was not deleting the openGL texture.