प्रोग्राम iPhone पर मेमोरी उपयोग को पुनः प्राप्त करता है


101

मैं अपने iPhone ऐप को किसी भी समय, प्रोग्रामेटिक रूप से उपयोग करने की स्मृति को पुनः प्राप्त करने का प्रयास कर रहा हूं। हाँ मैं ObjectAlloc / लीक के बारे में पता कर रहा हूँ। मुझे इसमें कोई दिलचस्पी नहीं है, केवल यह जानने के लिए कि क्या कुछ कोड लिखना संभव है और बाइट्स की मात्रा का उपयोग किया जा सकता है और इसे NSLog के माध्यम से रिपोर्ट करें।

धन्यवाद।


यार, मैं पहले से ही स्मृति उपयोग सफलतापूर्वक प्राप्त करता हूं; लेकिन क्या आप मेरे संबंधित सवालों के जवाब देने में मदद कर सकते हैं? stackoverflow.com/questions/47071265/…
स्वर्ग

यहाँ सही उत्तर पाने का तरीका बताया गया है: stackoverflow.com/a/57315975/1058199
एलेक्स ज़ावाटोन

जवाबों:


134

आपके एप्लिकेशन का उपयोग कर रहे मेमोरी की वास्तविक बाइट्स प्राप्त करने के लिए, आप नीचे दिए गए उदाहरण की तरह कुछ कर सकते हैं। हालांकि, आपको वास्तव में विभिन्न प्रोफाइलिंग टूल्स से परिचित होना चाहिए और साथ ही वे आपको ओवर-ऑल-यूज़ की बेहतर तस्वीर देने के लिए डिज़ाइन किए गए हैं।

#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
धन्यवाद, वास्तव में मैं क्या खोज रहा था। क्या यह तरीका ऐप स्टोर सुरक्षित है?
बुजू

3
यदि आप Cmd + पर क्लिक करें task_basic_info, तो ऐसा लगता है कि अब इसका उपयोग नहीं किया जाना चाहिए और इसे mach_task_basic_info से बदल दिया जाना चाहिए। मेरा अनुमान है कि यह संस्करण 64-बिट आर्किटेक्चर के साथ संगत नहीं है, लेकिन वास्तव में निश्चित नहीं है।
cccrack

14
मेरे मामले में, एक्सकोड में मेमोरी रिपोर्ट जितनी बार सामने आती है, उससे दोगुनी रकम वापस आ जाती है। निश्चित नहीं है कि इसका क्या करना है।
मॉर्क्रोम

1
अन्य एप्लिकेशन द्वारा मेमोरी उपयोग कैसे प्राप्त करें?
अमित खंडेलवाल

1
@Morkrom क्या आपने सोचा है कि क्यों? मुझे लगभग दो बार बड़े चल रहे सिम्युलेटर और लगभग 3 बार डिवाइस पर एक ही समस्या है।
जूलियन क्राल

31

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

यहाँ NS_og () में तेज़ी से लीक होने की स्थिति को बढ़ाने के लिए report_memory () बढ़ाया गया है।

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
आकार का आकार (जानकारी) के बजाय TASK_BASIC_INFO_COUNT होना चाहिए - यह गलती समान कोड वाली कई जगहों पर कॉपी-पेस्ट की गई
Maxim Kholyavkin

18

यह 07/01/2019 को Mojave 10.4.6 में Xcode 11 पर परीक्षण किया गया है।

पिछले सभी उत्तर गलत परिणाम देते हैं

यहां बताया गया है कि एप्पल के क्विन "द एस्किमो!" द्वारा लिखित अपेक्षित मूल्य कैसे प्राप्त करें।

यह Xcode के डीबग नेविगेटर में मेमोरी गेज से वैल्यूphys_footprint से Darwin > Mach > task_infoऔर बारीकी से मिलान का उपयोग करता है ।

लौटाया गया मान बाइट्स में है।

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  
}  

स्विफ्ट विधियों के वर्ग स्तर सेट बनाने के लिए इसे थोड़ा संशोधित करना प्रदर्शन के लिए एमबी में वास्तविक बाइट्स और स्वरूपित आउटपुट की आसान वापसी की अनुमति देता है। मैं इसे एक ही परीक्षण के कई पुनरावृत्तियों से पहले और बाद में उपयोग की जाने वाली मेमोरी को लॉग करने के लिए एक स्वचालित यूआईस्टेस्ट सूट के हिस्से के रूप में उपयोग करता हूं, यह देखने के लिए कि क्या हमारे पास कोई संभावित लीक या आवंटन हैं जिन्हें हमें देखने की आवश्यकता है।

//  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))")
    }
}

क्या करना है अगर हम जानना चाहते हैं कि कुछ अन्य एप्लीकेटन (स्काइप) का कितना राम उपयोग कर रहा है?
विकास बंसल

4

स्विफ्ट 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"))
    }

}

1
इस कोड का उपयोग करने वाला मेमोरी उपयोग डिबगर से x3 गुना मेमोरी उपयोग दिखाता है। क्यों?

1
खैर, मुझे लगता है कि आपको बाइट्स से मेगाबाइट्स प्राप्त करने के लिए, (1024*1024)द्वारा विभाजित करने की आवश्यकता है 1000000
ivanzoid

यह x3 का अंतर नहीं बनाता है।
दशकों

यह एक वास्तविक मेमोरी मूल्य देता है, जैसा कि Xcode डिबगर में है, धन्यवाद
tatiana_c

2

यहाँ एक स्विफ्ट 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
इस कोड का उपयोग करने वाला मेमोरी उपयोग डिबगर से x3 गुना मेमोरी उपयोग दिखाता है। क्यों?

यहां तक ​​कि मेरे पास लगभग तीन गुना अधिक मेरे लिए एक ही मुद्दा है कि प्रोफ़ाइल में क्या दिखाई दे रहा है?
सैंडी


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

`` `


न केवल यह गलत मान लौटाता है, "भौतिकी" मेमोरी पद्धति को कॉल करने का मतलब है कि आपको वास्तव में अपने कोड की अधिक बार समीक्षा करने की आवश्यकता है।
एलेक्स ज़ावाटोन
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.