Programaticamente recuperar o uso de memory no iPhone

Estou tentando recuperar a quantidade de memory que meu aplicativo para iPhone está usando a qualquer momento, programaticamente. Sim, estou ciente sobre o ObjectAlloc / Leaks. Eu não estou interessado naqueles, apenas para saber se é possível escrever algum código e obter a quantidade de bytes sendo usados ​​e reportá-lo via NSLog.

Obrigado.

Para obter os bytes reais de memory que seu aplicativo está usando, você pode fazer algo parecido com o exemplo abaixo. No entanto, você deve se familiarizar com as várias ferramentas de criação de perfil, assim como elas são projetadas para fornecer uma imagem muito melhor do uso geral.

#import  // ... void report_memory(void) { struct task_basic_info info; mach_msg_type_number_t size = sizeof(info); kern_return_t kerr = task_info(mach_task_self(), TASK_BASIC_INFO, (task_info_t)&info, &size); if( kerr == KERN_SUCCESS ) { NSLog(@"Memory in use (in bytes): %lu", info.resident_size); NSLog(@"Memory in use (in MB): %f", ((CGFloat)info.resident_size / 1000000)); } else { NSLog(@"Error with task_info(): %s", mach_error_string(kerr)); } } 

Há também um campo na estrutura info.virtual_size que fornecerá o número de bytes de memory virtual disponível (ou a memory alocada para seu aplicativo como possível memory virtual em qualquer evento). O código ao qual o pgb está vinculado fornecerá a quantidade de memory disponível para o dispositivo e o tipo de memory que é.

Os headers de TASK_BASIC_INFO dizem:

 /* Don't use this, use MACH_TASK_BASIC_INFO instead */ 

Aqui está uma versão usando MACH_TASK_BASIC_INFO :

 void report_memory(void) { struct mach_task_basic_info info; mach_msg_type_number_t size = MACH_TASK_BASIC_INFO_COUNT; kern_return_t kerr = task_info(mach_task_self(), MACH_TASK_BASIC_INFO, (task_info_t)&info, &size); if( kerr == KERN_SUCCESS ) { NSLog(@"Memory in use (in bytes): %u", info.resident_size); } else { NSLog(@"Error with task_info(): %s", mach_error_string(kerr)); } } 

Aqui está report_memory () aprimorado para mostrar rapidamente o status de vazamento no NSLog ().

 void report_memory(void) { static unsigned last_resident_size=0; static unsigned greatest = 0; static unsigned last_greatest = 0; struct task_basic_info info; mach_msg_type_number_t size = sizeof(info); kern_return_t kerr = task_info(mach_task_self(), TASK_BASIC_INFO, (task_info_t)&info, &size); if( kerr == KERN_SUCCESS ) { int diff = (int)info.resident_size - (int)last_resident_size; unsigned latest = info.resident_size; if( latest > greatest ) greatest = latest; // track greatest mem usage int greatest_diff = greatest - last_greatest; int latest_greatest_diff = latest - greatest; NSLog(@"Mem: %10u (%10d) : %10d : greatest: %10u (%d)", info.resident_size, diff, latest_greatest_diff, greatest, greatest_diff ); } else { NSLog(@"Error with task_info(): %s", mach_error_string(kerr)); } last_resident_size = info.resident_size; last_greatest = greatest; } 

Solução rápida da resposta de Jason Coco :

 func reportMemory() { let name = mach_task_self_ let flavor = task_flavor_t(TASK_BASIC_INFO) let basicInfo = task_basic_info() var size: mach_msg_type_number_t = mach_msg_type_number_t(sizeofValue(basicInfo)) let pointerOfBasicInfo = UnsafeMutablePointer.alloc(1) let kerr: kern_return_t = task_info(name, flavor, UnsafeMutablePointer(pointerOfBasicInfo), &size) let info = pointerOfBasicInfo.move() pointerOfBasicInfo.dealloc(1) if kerr == KERN_SUCCESS { print("Memory in use (in bytes): \(info.resident_size)") } else { print("error with task info(): \(mach_error_string(kerr))") } } 

Swift 3.1 (a partir de 8 de agosto de 2017)

 func getMemory() { var taskInfo = mach_task_basic_info() var count = mach_msg_type_number_t(MemoryLayout.size)/4 let kerr: kern_return_t = withUnsafeMutablePointer(to: &taskInfo) { $0.withMemoryRebound(to: integer_t.self, capacity: 1) { task_info(mach_task_self_, task_flavor_t(MACH_TASK_BASIC_INFO), $0, &count) } } if kerr == KERN_SUCCESS { let usedMegabytes = taskInfo.resident_size/1000000 print("used megabytes: \(usedMegabytes)") } else { print("Error with task_info(): " + (String(cString: mach_error_string(kerr), encoding: String.Encoding.ascii) ?? "unknown error")) } } 

Aqui está uma versão do Swift 3:

 func mach_task_self() -> task_t { return mach_task_self_ } func getMegabytesUsed() -> Float? { var info = mach_task_basic_info() var count = mach_msg_type_number_t(MemoryLayout.size(ofValue: info) / MemoryLayout.size) let kerr = withUnsafeMutablePointer(to: &info) { infoPtr in return infoPtr.withMemoryRebound(to: integer_t.self, capacity: Int(count)) { (machPtr: UnsafeMutablePointer) in return task_info( mach_task_self(), task_flavor_t(MACH_TASK_BASIC_INFO), machPtr, &count ) } } guard kerr == KERN_SUCCESS else { return nil } return Float(info.resident_size) / (1024 * 1024) } 

Abaixo está a resposta correta:

“ `

 float GetTotalPhysicsMemory() { struct task_basic_info info; mach_msg_type_number_t size = sizeof(info); kern_return_t kr; kr = task_info(mach_task_self(), TASK_BASIC_INFO, (task_info_t)&info, &size); if (kr == KERN_SUCCESS) return (float)(info.resident_size) / 1024.0 / 1024.0; else return 0; } 

“ `