maksymalny budżet pamięci aplikacji na ios

Wyniki testów z narzędziem Split napisał (link jest w jego odpowiedzi):

Urządzenie: (ilość awarii / całkowita ilość / procent całości)

• iPad1: 127mb/256MB / 49%
• iPad2: 275MB / 512MB / 53%
• iPad3: 645MB / 1024MB / 62%
• iPad4: 585mb/1024MB/57% (iOS 8.1)
• iPad Mini 1. generacja: 297MB/512MB/58%
• iPad Mini retina: 696MB/ 1024MB / 68% (iOS 7.1)
• iPad Air: 697MB / 1024MB / 68%
IPad Air 2: 1383MB / 2048MB / 68% (iOS 10.2.1) [[7]} iPad Pro 9.7": 1395mb/1971mb/71% (iOS 10.0.2 (14a456)) IPad Pro 10.5": 3057/4000/76% (iOS 11 beta4) IPad Pro 12.9" (2015): 3058/3999/76% (iOS 11.2.1) IPad Pro 12.9" (2017): 3057/3974/77% (iOS 11 beta4)
• iPod touch 4th gen: 130MB/256MB/51% (iOS 6.1.1)
IPod touch 5th gen: 286MB/ 512MB / 56% (iOS 7.0)
• iPhone4: 325mb/512MB / 63%
• iPhone4s: 286MB/512MB / 56%
• iPhone5: 645MB / 1024MB / 62%
• iPhone5s: 646MB / 1024MB / 63%
• iPhone6: 645MB / 1024MB / 62% (iOS 8.x)
• iPhone6+: 645MB / 1024MB / 62% (iOS 8.x)
• iPhone6s: 1396mb/2048MB/68% (iOS 9.2)
• iPhone6s+: 1392mb/2048MB/68% (iOS 10.2.1)
• iPhoneSE: 1395mb / 2048MB / 69% (iOS 9.3)
• iPhone7: 1395/2048MB/68% (iOS 10.2)
• iPhone7+: 2040mb/3072MB/66% (iOS 10.2.1)
[[7]} iPhone X: 1392/2785/50% (iOS 11.2.1)

Stworzyłem małe narzędzie, które stara się przeznaczyć jak najwięcej pamięci do awarii i rejestruje, kiedy Ostrzeżenia pamięci i awarii się stało. Pomaga to dowiedzieć się, jaki jest budżet pamięci dla każdego urządzenia z systemem iOS.

Https://github.com/Split82/iOSMemoryBudgetTest

W mojej aplikacji doświadczenie użytkownika jest lepsze, jeśli używana jest więcej pamięci, więc muszę zdecydować, czy naprawdę powinienem zwolnić Wszystkie pamięć, którą mogę w didReceiveMemoryWarning. Na podstawie odpowiedzi Splitu i Jaspera Pol, użycie maksymalnie 45% całkowitej pamięci urządzenia wydaje się być bezpiecznym progiem (dzięki chłopaki).

Na wypadek, gdyby ktoś chciał przyjrzeć się mojej rzeczywistej realizacji:

#import "mach/mach.h"

- (void)didReceiveMemoryWarning
{
    // Remember to call super
    [super didReceiveMemoryWarning];

    // If we are using more than 45% of the memory, free even important resources,
    // because the app might be killed by the OS if we don't
    if ([self __getMemoryUsedPer1] > 0.45)
    {
        // Free important resources here
    }

    // Free regular unimportant resources always here
}

- (float)__getMemoryUsedPer1
{
    struct mach_task_basic_info info;
    mach_msg_type_number_t size = sizeof(info);
    kern_return_t kerr = task_info(mach_task_self(), MACH_TASK_BASIC_INFO, (task_info_t)&info, &size);
    if (kerr == KERN_SUCCESS)
    {
        float used_bytes = info.resident_size;
        float total_bytes = [NSProcessInfo processInfo].physicalMemory;
        //NSLog(@"Used: %f MB out of %f MB (%f%%)", used_bytes / 1024.0f / 1024.0f, total_bytes / 1024.0f / 1024.0f, used_bytes * 100.0f / total_bytes);
        return used_bytes / total_bytes;
    }
    return 1;
}

Swift (na podstawie tej odpowiedzi):

func __getMemoryUsedPer1() -> Float
{
    let MACH_TASK_BASIC_INFO_COUNT = (sizeof(mach_task_basic_info_data_t) / sizeof(natural_t))
    let name = mach_task_self_
    let flavor = task_flavor_t(MACH_TASK_BASIC_INFO)
    var size = mach_msg_type_number_t(MACH_TASK_BASIC_INFO_COUNT)
    var infoPointer = UnsafeMutablePointer<mach_task_basic_info>.alloc(1)
    let kerr = task_info(name, flavor, UnsafeMutablePointer(infoPointer), &size)
    let info = infoPointer.move()
    infoPointer.dealloc(1)
    if kerr == KERN_SUCCESS
    {
        var used_bytes: Float = Float(info.resident_size)
        var total_bytes: Float = Float(NSProcessInfo.processInfo().physicalMemory)
        println("Used: \(used_bytes / 1024.0 / 1024.0) MB out of \(total_bytes / 1024.0 / 1024.0) MB (\(used_bytes * 100.0 / total_bytes)%%)")
        return used_bytes / total_bytes
    }
    return 1
}

Rozwidlając repo, zbudowałem taki, aby przetestować pamięć iOS, którą można przypisać do dzisiejszego Rozszerzenia

IOSMemoryBudgetTestForExtension

Poniżej jest wynik, który dostałem w iPhone 5s

Ostrzeżenie o pamięci 10 MB

Aplikacja rozbita na 12 MB

W ten sposób Apple pozwala jedynie rozszerzeniom pracować z pełnym potencjałem.

Powinieneś obejrzeć sesję 147 z WWDC 2010 Session videos . Jest to "zaawansowana Optymalizacja wydajności na iPhone OS, część 2".
Istnieje wiele dobrych rad na temat optymalizacji pamięci.

Niektóre z porad to:

• Użyj zagnieżdżonych NSAutoReleasePools, aby upewnić się, że zużycie pamięci nie wzrasta.
• Użyj CGImageSource Podczas tworzenia miniatur z dużych obrazów.
• reaguj na ostrzeżenia o niskiej pamięci.

- (float)__getMemoryUsedPer1
{
    struct mach_task_basic_info info;
    mach_msg_type_number_t size = MACH_TASK_BASIC_INFO;
    kern_return_t kerr = task_info(mach_task_self(), MACH_TASK_BASIC_INFO, (task_info_t)&info, &size);
    if (kerr == KERN_SUCCESS)
    {
        float used_bytes = info.resident_size;
        float total_bytes = [NSProcessInfo processInfo].physicalMemory;
        //NSLog(@"Used: %f MB out of %f MB (%f%%)", used_bytes / 1024.0f / 1024.0f, total_bytes / 1024.0f / 1024.0f, used_bytes * 100.0f / total_bytes);
        return used_bytes / total_bytes;
    }
    return 1;
}

Jeśli użyjesz TASK_BASIC_INFO_COUNT zamiast MACH_TASK_BASIC_INFO, otrzymasz

Kerr = = KERN_INVALID_ARGUMENT (4)

Stworzyłem jeszcze jedną listę sortując listę Jasperów po PAMIĘCI RAM urządzenia (zrobiłem własne testy za pomocą narzędzia Split i poprawiłem niektóre wyniki-Sprawdź moje komentarze w tym wątku).

Pamięć RAM urządzenia: zakres procentowy do awarii

• 256MB: 49% - 51%
• 512MB: 53% - 63%
• 1024MB: 57% - 68%
• 2048MB: 68% - 69%
• 3072MB: 66%
• 4096MB: 77%

Przypadek szczególny:

• iPhone X (3072MB): 50%

Pamięć RAM urządzenia może być odczytywana łatwo:

[NSProcessInfo processInfo].physicalMemory

Z mojego doświadczenia wynika, że bezpiecznie jest używać 45% dla urządzeń 1GB, 50% dla urządzeń 2/3GB i 55% dla urządzeń 4GB. Procent dla macOS może być nieco większy.