web-dev-qa-db-fra.com

budget mémoire maximum de l'application ios

Je travaille sur un jeu iOS qui cible au minimum les 3gs. Nous utilisons des ressources HD pour les périphériques d’affichage rétine (iphone 4, iPod touch 4e génération).

En ce qui concerne la mémoire, l'iPod Touch 4ème génération semble être le périphérique le plus contraignant pour nous, car il a la même quantité de RAM (256 comparé à 512 pour l'iPhone 4)) que le 3G, mais nous utilisons des ressources HD L’application se bloquait lorsque vous essayez de charger 100-110 Mo de bélier, mais maintenant que nous n’avons plus que 70 Mo, nous n’avons jamais eu un crash de chargement.

Après de nombreuses recherches, il ne semble pas y avoir de limite stricte officielle, alors comment devrions-nous savoir quel budget de mémoire utiliser pour rester en sécurité? Nous voulons pouvoir donner aux artistes un budget qu’ils peuvent utiliser sans soucis de mémoire pour chaque carte.

iphoneiosmemorymemory-management
142
frilla

Je pense que vous avez répondu à votre propre question: essayez de ne pas dépasser la limite de 70 Mo. Toutefois, cela dépend vraiment de beaucoup de choses: quelle version d'iOS vous utilisez (pas le SDK), combien d'applications s'exécutant en arrière-plan, quelle mémoire exacte vous utilisez etc.

Évitez simplement les éclaboussures de mémoire instantanées (par exemple, vous utilisez 40 Mo de RAM, puis allouez 80 Mo de plus pour un calcul court). Dans ce cas, iOS tuerait votre application immédiatement.

Vous devez également envisager le chargement paresseux des ressources (chargez-les uniquement lorsque vous en avez réellement besoin et pas avant).

38
Max

Résultats des tests avec l'utilitaire Split a écrit (le lien est dans sa réponse):

appareil: (montant du crash/montant total/pourcentage du total)

  • iPad1: 127 Mo/256 Mo/49%
  • iPad2: 275 Mo/512 Mo/53%
  • iPad3: 645 Mo/1024 Mo/62%
  • iPad4: 585 Mo/1024 Mo/57% (iOS 8.1)
  • iPad Mini 1ère génération: 297 Mo/512 Mo/58%
  • iPad Mini rétine: 696 Mo/1024 Mo/68% (iOS 7.1)
  • iPad Air: 697 Mo/1024 Mo/68%
  • iPad Air 2: 1383 Mo/2048 Mo/68% (iOS 10.2.1)
  • iPad Pro 9.7 ": 1395 Mo/1971 Mo/71% (iOS 10.0.2 (14A456))
  • iPad Pro 10.5 ": 3057/4000/76% (iOS 11 bêta4)
  • iPad Pro 12,9 "(2015): 3058/3999/76% (iOS 11.2.1)
  • iPad Pro 12,9 "(2017): 3057/3974/77% (iOS 11 bêta4)
  • iPad Pro 11.0 "(2018): 2858/3769/76% (iOS 12.1)
  • iPad Pro 12.9 "(2018, 1 To): 4598/5650/81% (iOS 12.1)
  • iPod touch 4e génération: 130 Mo/256 Mo/51% (iOS 6.1.1)
  • iPod touch 5e génération: 286 Mo/512 Mo/56% (iOS 7.0)
  • iPhone4: 325 Mo/512 Mo/63%
  • iPhone4s: 286 Mo/512 Mo/56%
  • iPhone5: 645 Mo/1024 Mo/62%
  • iPhone5s: 646 Mo/1024 Mo/63%
  • iPhone6: 645 Mo/1024 Mo/62% (iOS 8.x)
  • iPhone6 ​​+: 645 Mo/1024 Mo/62% (iOS 8.x)
  • iPhone6s: 1396 Mo/2048 Mo/68% (iOS 9.2)
  • iPhone6s +: 1392 Mo/2048 Mo/68% (iOS 10.2.1)
  • iPhoneSE: 1395 Mo/2048 Mo/69% (iOS 9.3)
  • iPhone7: 1395/2048 Mo/68% (iOS 10.2)
  • iPhone7 +: 2040 Mo/3072 Mo/66% (iOS 10.2.1)
  • iPhone8: 1364/1990Mo/70% (iOS 12.1)
  • iPhone X: 1392/2785/50% (iOS 11.2.1)
  • iPhone XS: 2040/3754/54% (iOS 12.1)
  • iPhone XS Max: 2039/3735/55% (iOS 12.1)
  • iPhone XR: 1792/2813/63% (iOS 12.1)
391
Jasper

J'ai créé un petit utilitaire qui tente d'allouer le plus de mémoire possible au crash et qui enregistre quand des avertissements de mémoire et un crash sont survenus. Cela aide à savoir quel est le budget de mémoire d'un appareil iOS.

https://github.com/Split82/iOSMemoryBudgetTest

130
Split

Dans mon application, l'expérience utilisateur est meilleure si plus de mémoire est utilisée. Je dois donc décider si je dois réellement libérer la totalité de la mémoire que je peux dans didReceiveMemoryWarning. D'après la réponse de Split et de Jasper Pol, l'utilisation d'un maximum de 45% de la mémoire totale de l'appareil semble être un seuil sûr (merci les gars).

Au cas où quelqu'un voudrait regarder ma mise en œuvre réelle:

#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 (basé sur cette réponse ):

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
}
17
cprcrack

En bricolant le dépôt SPLITS, j'en ai construit un pour tester la mémoire iOS pouvant être allouée à l'extension du jour.

iOSMemoryBudgetTestForExtension

Voici le résultat obtenu sur iPhone 5s

Avertissement de mémoire à 10 Mo

Application bloquée à 12 Mo

Par ce moyen Apple permet simplement à toute extension de fonctionner avec tout son potentiel.

8
Harsh

Vous devriez regarder la session 147 de vidéos de la WWDC 2010 Session . C'est "Optimisation avancée des performances sur iPhone OS, partie 2".
Il y a beaucoup de bons conseils sur l'optimisation de la mémoire.

Certains des conseils sont:

  • Utilisez NSAutoReleasePools imbriqué pour vous assurer que votre utilisation de la mémoire ne augmente pas.
  • Utilisez CGImageSource lors de la création de vignettes à partir d’images de grande taille.
  • Répondre aux avertissements de mémoire insuffisante.
7
Kobski
- (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;
}

Si on utilisera TASK_BASIC_INFO_COUNT au lieu de MACH_TASK_BASIC_INFO, vous obtiendrez

kerr == KERN_INVALID_ARGUMENT (4)

4
Dmitry Preobrazhenskiy

J'ai créé une liste supplémentaire en triant la liste Jaspers par périphérique RAM (j'ai fait mes propres tests avec l'outil Split et j'ai corrigé certains résultats - vérifiez mes commentaires dans le fil Jaspers).

RAM de l'appareil: plage de pourcentage de plantage

  • 256 Mo: 49% à 51%
  • 512Mo: 53% - 63%
  • 1024Mo: 57% - 68%
  • 2048Mo: 68% - 69%
  • 3072Mo: 66%
  • 4096Mo: 77%
  • 6144Mo: 81%

Cas spéciaux:

  • iPhone X (3072 Mo): 50%
  • iPhone XS/XS Max (4096Mo): 55%
  • iPhone XR (3072MB): non testé (veuillez poster les valeurs de crash dans les commentaires)

Device RAM peut être lu facilement:

[NSProcessInfo processInfo].physicalMemory

D'après mon expérience, il est prudent d'utiliser 45% pour les appareils 1 Go, 50% pour les appareils 2/3 Go et 55% pour les appareils 4 Go. Le pourcentage pour macOS peut être un peu plus grand.

2
Slyv