views:

89

answers:

2

Memory is an issue for iphone ipad app, especially for ipad, if one wants to do something big.

Well, these two snippets of codes can 1. get current available memory of the device; 2. force free memory.

Can we use it in the app? Will app store allow?

thanks

#import <mach/mach.h>
#import <mach/mach_host.h>

static 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);
}

Free memory

/* Allocate the remaining amount of free memory, minus 2 megs * /
size_t size = freemem - (2*1024*1024);
void *allocation = malloc(size);
bzero(allocation, size);
free(allocation);
+5  A: 

iOS manages its memory resources pretty well if you ask me. If you're having memory issues with your app you need to profile and identify what those memory issues are and optimise them.

Think of it from a user's perspective. Especially on multi-tasking capable iPhones/iPads (with 4.2). The user has apps in the background that he/she will want to go back to in some time. They open up your app - which nukes everything to make room for itself - and then they try to return to their other apps only to find they've been killed because your app killed them.

I wouldn't be too happy and would probably strongly reconsider using your app again in the future.

Apple will likely have the same opinion. Their job is make sure the users have the best experience possible, which is why they have rules and guidelines to start with.

Jasarien
Exactly what I was thinking.
Ehsan
While I don't know *iOS* in particular, if it will kill other apps because he allocates a massive amount of memory, then *iOS* is defective. If his app access the allocated VM then inactive apps may be swapped out, but if they're killed (except death by failed allocation) it's a defect in the OS.
Carter Galle
Carter - on iOS, apps are given memory warnings when memory becomes low. The app is given a chance to clean up some unnecessary memory hogs in order to free up some memory. If the memory is still too low after the memory warning then the app is jettisoned. This is the expected behaviour on iOS. When the frontmost app requests more memory than is available, background apps are terminated in order to fulfil the requirement. This is why Apple stresses that it's important to save anything critical when the app is sent into the background.
Jasarien
Carter - I believe apps that are running in the background (and not just suspended) are considered last when killing apps to free up memory, but it still always a possibility. This isn't a defect (although, your opinion may say it is), it is a design feature of the OS and an important one that iOS developers must take into account.
Jasarien
+4  A: 

Whether or not your app will be rejected, I have no idea.

However, this is a horrible idea to start with and won't work anyway.

As Jasarien said, your application will be running in an environment where it may be sharing resources with other applications. It is a far better solution to optimize the memory use within your application -- to minimize memory use -- and make your app as system friendly as possible. Resources are scarce, use them sparingly.

However, the "allocate remaining memory" code is bogus. There is no guarantee that the free memory will be contiguous. It is quite likely that allocation will fail.

The real question is exactly why does your application use so much memory and what have you done to minimize it?

bbum