Программное получение информации об использовании памяти на iPhone

102

Я пытаюсь получить объем памяти, который мое приложение для iPhone использует в любое время программно. Да, я знаю об ObjectAlloc / Leaks. Меня это не интересует, только чтобы знать, можно ли написать код, получить количество используемых байтов и сообщить об этом через NSLog.

Спасибо.

ios  objective-c  iphone  cocoa-touch  memory 
— Coocoo4Cocoa
источник
Чувак, я уже успешно получил данные об использовании памяти; Но можете ли вы помочь ответить на мои вопросы по теме? stackoverflow.com/questions/47071265/…
— Paradise
Вот как получить правильный ответ: stackoverflow.com/a/57315975/1058199
— Alex Zavatone 01

Ответы:

135

Чтобы получить фактические байты памяти, которые использует ваше приложение, вы можете сделать что-то вроде примера ниже. Однако вам действительно следует ознакомиться с различными инструментами профилирования, так как они разработаны, чтобы дать вам гораздо лучшее представление об их использовании в целом.

#import <mach/mach.h>

// ...

void report_memory(void) {
  struct task_basic_info info;
  mach_msg_type_number_t size = TASK_BASIC_INFO_COUNT;
  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 MiB): %f", ((CGFloat)info.resident_size / 1048576));
  } else {
    NSLog(@"Error with task_info(): %s", mach_error_string(kerr));
  }
}

В структуре info.virtual_size также есть поле, которое даст вам количество байтов доступной виртуальной памяти (или памяти, выделенной вашему приложению в качестве потенциальной виртуальной памяти в любом случае). Код, на который ссылается pgb, даст вам объем памяти, доступной устройству, и тип памяти.

— Джейсон Коко
источник
4
спасибо, именно то, что я искал. Безопасен ли этот метод в магазине приложений?
— Buju
3
Если вы нажмете Cmd + Click task_basic_info, кажется, что теперь его не следует использовать и заменить на mach_task_basic_info. Я предполагаю, что эта версия несовместима с 64-битной архитектурой, но не совсем уверен.
— cprcrack
14
В моем случае возвращенная сумма вдвое больше, чем выводится в отчете о памяти в XCode. Не уверен, что с этим делать.
— Morkrom
1
Как получить использование памяти другими приложениями?
— Amit Khandelwal
1
@Morkrom, ты понял, почему? У меня такая же проблема с симулятором бега в два раза больше и почти в 3 раза на устройстве.
— Джулиан Крол
32

Заголовки TASK_BASIC_INFOговорят:

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

Вот версия с использованием 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));
    }
}
— комбинаторный
источник
Есть идеи, почему зарегистрированное здесь значение примерно в два раза больше на симуляторе, чем в отчетах Xcode, и в три раза на реальном устройстве?
— Джулиан Крол
1
Не знаю, в чем разница. Это был бы хороший новый вопрос.
— комбинаторный
1
Я нашел разницу. Это из-за резидентной памяти, а не из-за живых байтов,
— Джулиан Крол
можем ли мы получить использование памяти другими приложениями ?? @combinatorial
— Викас
1
@VikasBansal нет, не можешь.
— комбинаторный
18

Вот улучшенный report_memory (), позволяющий быстро отображать статус утечки в 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;
}
— Дуг Налл
источник
2
size должен быть TASK_BASIC_INFO_COUNT вместо sizeof (info) - эта ошибка скопирована во многие места с тем же кодом
— Максим Холявкин
18

Это было протестировано на Xcode 11 в Mojave 10.4.6 01.07.2019.

Все предыдущие ответы возвращают неверный результат .

Вот как получить ожидаемое значение, написанное Куинном из Apple «Эскимос!».

При этом используется phys_footprintпеременная от Darwin > Mach > task_infoи близко соответствует значению в индикаторе памяти в навигаторе отладки Xcode .

Возвращаемое значение выражено в байтах.

https://forums.developer.apple.com/thread/105088#357415

Исходный код следует.

func memoryFootprint() -> mach_vm_size_t? {  
    // The `TASK_VM_INFO_COUNT` and `TASK_VM_INFO_REV1_COUNT` macros are too  
    // complex for the Swift C importer, so we have to define them ourselves.  
    let TASK_VM_INFO_COUNT = mach_msg_type_number_t(MemoryLayout<task_vm_info_data_t>.size / MemoryLayout<integer_t>.size)  
    let TASK_VM_INFO_REV1_COUNT = mach_msg_type_number_t(MemoryLayout.offset(of: \task_vm_info_data_t.min_address)! / MemoryLayout<integer_t>.size)  
    var info = task_vm_info_data_t()  
    var count = TASK_VM_INFO_COUNT  
    let kr = withUnsafeMutablePointer(to: &info) { infoPtr in  
        infoPtr.withMemoryRebound(to: integer_t.self, capacity: Int(count)) { intPtr in  
            task_info(mach_task_self_, task_flavor_t(TASK_VM_INFO), intPtr, &count)  
        }  
    }  
    guard  
        kr == KERN_SUCCESS,  
        count >= TASK_VM_INFO_REV1_COUNT  
    else { return nil }  
    return info.phys_footprint  
}

Немного изменив это, чтобы создать набор методов Swift уровня класса, можно легко вернуть фактические байты и отформатировать вывод в МБ для отображения. Я использую это как часть автоматизированного набора UITest для регистрации памяти, использованной до и после нескольких итераций одного и того же теста, чтобы увидеть, есть ли у нас какие-либо потенциальные утечки или выделения, которые нам нужно изучить.

//  Created by Alex Zavatone on 8/1/19.
//

class Memory: NSObject {

    // From Quinn the Eskimo at Apple.
    // https://forums.developer.apple.com/thread/105088#357415

    class func memoryFootprint() -> Float? {
        // The `TASK_VM_INFO_COUNT` and `TASK_VM_INFO_REV1_COUNT` macros are too
        // complex for the Swift C importer, so we have to define them ourselves.
        let TASK_VM_INFO_COUNT = mach_msg_type_number_t(MemoryLayout<task_vm_info_data_t>.size / MemoryLayout<integer_t>.size)
        let TASK_VM_INFO_REV1_COUNT = mach_msg_type_number_t(MemoryLayout.offset(of: \task_vm_info_data_t.min_address)! / MemoryLayout<integer_t>.size)
        var info = task_vm_info_data_t()
        var count = TASK_VM_INFO_COUNT
        let kr = withUnsafeMutablePointer(to: &info) { infoPtr in
            infoPtr.withMemoryRebound(to: integer_t.self, capacity: Int(count)) { intPtr in
                task_info(mach_task_self_, task_flavor_t(TASK_VM_INFO), intPtr, &count)
            }
        }
        guard
            kr == KERN_SUCCESS,
            count >= TASK_VM_INFO_REV1_COUNT
            else { return nil }

        let usedBytes = Float(info.phys_footprint)
        return usedBytes
    }

    class func formattedMemoryFootprint() -> String
    {
        let usedBytes: UInt64? = UInt64(self.memoryFootprint() ?? 0)
        let usedMB = Double(usedBytes ?? 0) / 1024 / 1024
        let usedMBAsString: String = "\(usedMB)MB"
        return usedMBAsString
     }
}

Наслаждайтесь!

Примечание: предприимчивый программист может захотеть добавить в класс статическое средство форматирования, чтобы usedMBAsStringвозвращалось только 2 значащих десятичных разряда .

— Алекс Заватоне
источник
7

Быстрое решение ответа Джейсона Коко :

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<task_basic_info>.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))")
    }
}
— Назарий Влизло
источник
что делать, если мы хотим узнать, сколько оперативной памяти использует другое приложение (Skype)?
— Vikas Bansal
4

Swift 3.1 (по состоянию на 8 августа 2017 г.)

func getMemory() {

    var taskInfo = mach_task_basic_info()
    var count = mach_msg_type_number_t(MemoryLayout<mach_task_basic_info>.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/(1024*1024)
        print("used megabytes: \(usedMegabytes)")
    } else {
        print("Error with task_info(): " +
            (String(cString: mach_error_string(kerr), encoding: String.Encoding.ascii) ?? "unknown error"))
    }

}
— BennyTheNerd
источник
1
Использование памяти с использованием этого кода показывает в 3 раза больше использования памяти отладчиком. Зачем?
1
Ну, я думаю, вам нужно разделить на (1024*1024), а не на 1000000, чтобы получить мегабайты из байтов.
— ivanzoid 05
Это не имеет значения для x3.
— декады
он дает реальное значение памяти, как в отладчике Xcode, спасибо
— tatiana_c
2

Вот версия 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<integer_t>.size)
    let kerr = withUnsafeMutablePointer(to: &info) { infoPtr in
        return infoPtr.withMemoryRebound(to: integer_t.self, capacity: Int(count)) { (machPtr: UnsafeMutablePointer<integer_t>) 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)   
}
— Джеффбейли
источник
2
Использование памяти с использованием этого кода показывает в 3 раза больше использования памяти отладчиком. Зачем?
даже у меня такая же проблема почти в три раза выше, чем у меня в профиле?
— Сэнди
-1

Версия Objective-C:

size_t memoryFootprint()
{
    task_vm_info_data_t vmInfo;
    mach_msg_type_number_t count = TASK_VM_INFO_COUNT;
    kern_return_t result = task_info(mach_task_self(), TASK_VM_INFO, (task_info_t) &vmInfo, &count);
    if (result != KERN_SUCCESS)
        return 0;
    return static_cast<size_t>(vmInfo.phys_footprint);
}
— Джимми Инь
источник
-2

Вот правильный ответ:

`` ''

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

`` ''

— rensq
источник
Это не только возвращает неверное значение, но и вызов метода «Physics» memory означает, что вам действительно нужно чаще проверять свой код.
— Alex Zavatone 01
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.