Recuperar mediante progtwigción el uso de memoria en iPhone

Estoy tratando de recuperar la cantidad de memoria que mi aplicación de iPhone está usando en cualquier momento, programáticamente. Sí, soy consciente de ObjectAlloc / Leaks. No estoy interesado en eso, solo para saber si es posible escribir algún código y obtener la cantidad de bytes que se utilizan e informarlo a través de NSLog.

Gracias.

Para obtener los bytes reales de memoria que está usando su aplicación, puede hacer algo como el siguiente ejemplo. Sin embargo, realmente debe familiarizarse con las diversas herramientas de creación de perfiles, así como también están diseñadas para ofrecerle una mejor idea del uso general.

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

También hay un campo en la estructura info.virtual_size que le dará la cantidad de bytes de memoria virtual disponible (o memoria asignada a su aplicación como memoria virtual potencial en cualquier caso). El código al que enlaza pgb le dará la cantidad de memoria disponible para el dispositivo y qué tipo de memoria es.

Los encabezados de TASK_BASIC_INFO dicen:

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

Aquí hay una versión que usa 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)); } } 

Aquí está el informe_memoria () mejorado para mostrar rápidamente el estado de la fuga en el 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; } 

Solución Swift de la respuesta 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 (desde el 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")) } } 

Aquí hay una versión de 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) } 

A continuación está la respuesta correcta:

“ `

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

“ `