para - transferir datos de android a iphone

ios aplicación de memoria máxima de presupuesto

Question

Estoy trabajando en un juego iOS que apunta como mínimo a los 3gs. Estamos utilizando activos de alta definición para dispositivos de visualización Retina (iPhone 4, iPod touch de 4ta generación).

En cuanto a la memoria, Ipod Touch 4ta generación parece ser el dispositivo más restrictivo para nosotros, ya que tiene la misma cantidad de RAM (256 en comparación con 512 de Iphone 4) que 3gs, pero estamos utilizando activos de alta definición en ella. La aplicación solía colgarse cuando se intentaba cargar 100-110 m3 de memoria RAM, pero ahora que hemos bajado a 70 MB, nunca hemos tenido problemas de carga.

Después de muchas búsquedas, parece que no hay un límite fijo oficial, entonces, ¿cómo deberíamos saber qué presupuesto de memoria usar para estar seguros? Queremos ser capaces de dar a los artistas un presupuesto que puedan usar sin preocupaciones de memoria para cada mapa.

Answer 1

Al dividir el repositorio de SPLITS, construí uno para probar la memoria de iOS que se puede asignar a la extensión de hoy

iOSMemoryBudgetTestForExtension

A continuación se muestra el resultado que obtuve en el iPhone 5s

Advertencia de memoria en 10 MB

La aplicación se bloqueó a 12 MB

De esta forma, Apple simplemente permite que cualquier extensión funcione con todo su potencial .

Answer 2

Creé una lista más ordenando la lista de Jaspers por la RAM del dispositivo (hice mis propias pruebas con la herramienta de Split y corregí algunos resultados; revise mis comentarios en este hilo).

RAM del dispositivo: porcentaje de bloqueo

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

Caso especial:

• iPhone X (3072MB): 50%

La memoria RAM del dispositivo se puede leer fácilmente:

[NSProcessInfo processInfo].physicalMemory

Desde mi experiencia, es seguro usar el 45% para dispositivos de 1GB, el 50% para dispositivos de 2 / 3GB y el 55% para dispositivos de 4GB. El porcentaje de macOS puede ser un poco más grande.

Answer 3

Creé una utilidad pequeña que intenta asignar tanta memoria como sea posible para bloquear y graba cuando ocurrieron las advertencias de memoria y el bloqueo. Esto ayuda a averiguar cuál es el presupuesto de memoria para cualquier dispositivo con iOS.

https://github.com/Split82/iOSMemoryBudgetTest

Answer 4

Creo que ha respondido a su propia pregunta: trate de no ir más allá del límite de 70 Mb, sin embargo, realmente depende de muchas cosas: qué versión de iOS está usando (no SDK), cuántas aplicaciones se ejecutan en segundo plano, qué memoria exacta estás usando etc.

Solo evite las salpicaduras de memoria instantáneas (por ejemplo, está usando 40 MB de RAM y luego asigna 80 Mb más para algunos cálculos breves). En este caso, iOS mataría su aplicación de inmediato.

También debería considerar la carga diferida de los activos (cárguelos solo cuando realmente los necesite y no de antemano).

Answer 5

Debería ver la sesión 147 de los videos de la sesión de WWDC 2010 . Es "Optimización de rendimiento avanzada en iPhone OS, parte 2".
Hay muchos buenos consejos sobre optimizaciones de memoria.

Algunos de los consejos son:

• Use NSAutoReleasePool anidado para asegurarse de que el uso de la memoria no aumente.
• Utilice CGImageSource al crear miniaturas de imágenes grandes.
• Responda a las advertencias de memoria baja.

Answer 6

Resultados de las pruebas con la utilidad que Split escribió (el enlace está en su respuesta):

dispositivo: (cantidad de bloqueo / cantidad total / porcentaje del total)

• iPad1: 127 MB / 256 MB / 49%
• iPad2: 275MB / 512MB / 53%
• iPad3: 645MB / 1024MB / 62%
• iPad4: 585MB / 1024MB / 57% (iOS 8.1)
• iPad Mini 1ra generación: 297MB / 512MB / 58%
• Retina iPad Mini: 696MB / 1024MB / 68% (iOS 7.1)
• iPad Air: 697 MB / 1024 MB / 68%
• iPad Air 2: 1383 MB / 2048 MB / 68% (iOS 10.2.1)
• 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 4ª generación: 130MB / 256MB / 51% (iOS 6.1.1)
• iPod touch 5ta generación: 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)
• iPhone X: 1392/2785/50% (iOS 11.2.1)

Answer 7

En mi aplicación, la experiencia del usuario es mejor si se usa más memoria, así que tengo que decidir si realmente debería liberar toda la memoria posible en didReceiveMemoryWarning . Según la respuesta de Split y Jasper Pol, el uso de un máximo del 45% de la memoria total del dispositivo parece ser un umbral seguro (gracias chicos).

En caso de que alguien quiera ver mi implementación real:

#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 (basado en esta respuesta ):

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
}

Answer 8

- (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 uno va a usar TASK_BASIC_INFO_COUNT en lugar de MACH_TASK_BASIC_INFO, obtendrá

kerr == KERN_INVALID_ARGUMENT (4)