iOS – Ottenere l’utilizzo della CPU da applicazione

Qualcuno sa come ottenere l’utilizzo della CPU per un’applicazione? E ‘ sicuramente possibile, perché ci sono delle applicazioni in app store (Activity Monitor Touch) che può mostrare.

  • È necessario scoprire perché task_info() sta fallendo e che vi aiuterà a passare. Vedi la risposta a questa domanda COSÌ: stackoverflow.com/questions/5182924/…. Penso che sia cos non hai inizializzato port; utilizzare task_info_self() invece di port.
  • Wow, grazie per questo! Ora questo codice sembra funzionare. L’unica correzione che abbiamo bisogno di mach_task_self(), non task_info_self().
  • Si prega di scrivere come risposta. E attendere per qualche tempo, se questi non è altro buona risposta, accetta.
  • Già monitorare l’utilizzo della cpu con successo dal vostro modo; Ma può aiutare a rispondere alle mie domande correlate? stackoverflow.com/questions/47071265/…
InformationsquelleAutor ivanzoid | 2011-11-22

 

3 Replies
  1. 75

    Aggiornamento. Questo codice funziona per me:

    Aggiorna 2. Il thread_list stava perdendo, quindi, aggiunto vm_deallocate

    #import <mach/mach.h>
    #import <assert.h>
    
    float cpu_usage()
    {
        kern_return_t kr;
        task_info_data_t tinfo;
        mach_msg_type_number_t task_info_count;
    
        task_info_count = TASK_INFO_MAX;
        kr = task_info(mach_task_self(), TASK_BASIC_INFO, (task_info_t)tinfo, &task_info_count);
        if (kr != KERN_SUCCESS) {
            return -1;
        }
    
        task_basic_info_t      basic_info;
        thread_array_t         thread_list;
        mach_msg_type_number_t thread_count;
    
        thread_info_data_t     thinfo;
        mach_msg_type_number_t thread_info_count;
    
        thread_basic_info_t basic_info_th;
        uint32_t stat_thread = 0; //Mach threads
    
        basic_info = (task_basic_info_t)tinfo;
    
        //get threads in the task
        kr = task_threads(mach_task_self(), &thread_list, &thread_count);
        if (kr != KERN_SUCCESS) {
            return -1;
        }
        if (thread_count > 0)
            stat_thread += thread_count;
    
        long tot_sec = 0;
        long tot_usec = 0;
        float tot_cpu = 0;
        int j;
    
        for (j = 0; j < (int)thread_count; j++)
        {
            thread_info_count = THREAD_INFO_MAX;
            kr = thread_info(thread_list[j], THREAD_BASIC_INFO,
                             (thread_info_t)thinfo, &thread_info_count);
            if (kr != KERN_SUCCESS) {
                return -1;
            }
    
            basic_info_th = (thread_basic_info_t)thinfo;
    
            if (!(basic_info_th->flags & TH_FLAGS_IDLE)) {
                tot_sec = tot_sec + basic_info_th->user_time.seconds + basic_info_th->system_time.seconds;
                tot_usec = tot_usec + basic_info_th->user_time.microseconds + basic_info_th->system_time.microseconds;
                tot_cpu = tot_cpu + basic_info_th->cpu_usage / (float)TH_USAGE_SCALE * 100.0;
            }
    
        } //for each thread
    
        kr = vm_deallocate(mach_task_self(), (vm_offset_t)thread_list, thread_count * sizeof(thread_t));
        assert(kr == KERN_SUCCESS);
    
        return tot_cpu;
    }
    • Questo vuol dare di utilizzo della CPU per l’applicazione e l’utilizzo della CPU?
    • Grazie per la risposta veloce. C’è un modo per ottenere che il generale utilizzo della CPU?
    • io uso questo codice per calcolare l’utilizzo della cpu, ma è sempre 0 restituito da questa funzione.. Please help
    • c’è un modo per ottenere l’utilizzo della cpu da parte di id di processo?
    • possiamo avere la memoria di utilizzo di ogni applicazione?
    • In linea dove il microsecondi sono sommate, l’ora di sistema è aggiunto due volte. Questo probabilmente dovrebbe essere un tempo di utilizzo + sistema di tempo, invece.
    • Per il Thread di calcolo userei +=, piuttosto che fare il calcolo formula più, imvho sarebbe più chiaro
    • Che cosa circa con .NET 2.0? è possibile?
    • questo argomento è di circa solo per iOS (probabilmente funzionerà anche su OS X)
    • Qual è l’unità di tot_cpu? È per cento? Grazie.
    • L’utilizzo della CPU trovato in Debug Navigatore di xcode e di ciò che questa funzione dà sono diversi. Mi chiedo perché è così ?
    • tot_sec e tot_usec sono inutilizzati. la rimozione di queste variabili non ha alcun impatto sulla funzione. essi devono essere rimossi.
    • Thx per parlare di vm, Ma può aiutare a rispondere alle mie domande correlate? stackoverflow.com/questions/47071265/…
    • Si dovrebbe usare il tempo profiler in Strumenti e mostra le funzioni che utilizzano la CPU. La sua importante profilo prima e dopo le modifiche di profilo e un paio di volte. Profilo di app in esecuzione su un dispositivo, non un simulatore. Se, per esempio, il sovraccarico della CPU è una funzione che si ripete calcoli, cercare e memorizzare il risultato in memoria di primo e di lettura dalla memoria (se il calcolo viene ripetuto senza risultati diversi)
    • sì, Ma lo strumento non può aiutare a vivere app; Così ho monitor CPU/GPU/Memoria e dump dello stack trace a livello di programmazione
    • si dovrebbe git tag vostri comunicati.
    • ciao uomo, ho un bel guaio domanda; per “basic_info_th->cpu_usage”, qual è il significato reale di questo cpu_usage? Si rappresenta che l’uso di un secondo o di un periodo? Perché abbiamo bisogno di riassumere?

  2. 9

    Per Swift 3:

    fileprivate func cpuUsage() -> Double {
        var kr: kern_return_t
        var task_info_count: mach_msg_type_number_t
    
        task_info_count = mach_msg_type_number_t(TASK_INFO_MAX)
        var tinfo = [integer_t](repeating: 0, count: Int(task_info_count))
    
        kr = task_info(mach_task_self_, task_flavor_t(TASK_BASIC_INFO), &tinfo, &task_info_count)
        if kr != KERN_SUCCESS {
            return -1
        }
    
        var thread_list: thread_act_array_t? = UnsafeMutablePointer(mutating: [thread_act_t]())
        var thread_count: mach_msg_type_number_t = 0
        defer {
            if let thread_list = thread_list {
                vm_deallocate(mach_task_self_, vm_address_t(UnsafePointer(thread_list).pointee), vm_size_t(thread_count))
            }
        }
    
        kr = task_threads(mach_task_self_, &thread_list, &thread_count)
    
        if kr != KERN_SUCCESS {
            return -1
        }
    
        var tot_cpu: Double = 0
    
        if let thread_list = thread_list {
    
            for j in 0 ..< Int(thread_count) {
                var thread_info_count = mach_msg_type_number_t(THREAD_INFO_MAX)
                var thinfo = [integer_t](repeating: 0, count: Int(thread_info_count))
                kr = thread_info(thread_list[j], thread_flavor_t(THREAD_BASIC_INFO),
                                 &thinfo, &thread_info_count)
                if kr != KERN_SUCCESS {
                    return -1
                }
    
                let threadBasicInfo = convertThreadInfoToThreadBasicInfo(thinfo)
    
                if threadBasicInfo.flags != TH_FLAGS_IDLE {
                    tot_cpu += (Double(threadBasicInfo.cpu_usage) / Double(TH_USAGE_SCALE)) * 100.0
                }
            } //for each thread
        }
    
        return tot_cpu
    }
    
    fileprivate func convertThreadInfoToThreadBasicInfo(_ threadInfo: [integer_t]) -> thread_basic_info {
        var result = thread_basic_info()
    
        result.user_time = time_value_t(seconds: threadInfo[0], microseconds: threadInfo[1])
        result.system_time = time_value_t(seconds: threadInfo[2], microseconds: threadInfo[3])
        result.cpu_usage = threadInfo[4]
        result.policy = threadInfo[5]
        result.run_state = threadInfo[6]
        result.flags = threadInfo[7]
        result.suspend_count = threadInfo[8]
        result.sleep_time = threadInfo[9]
    
        return result
    }
    • Ho una domanda: È il calcolo dell’utilizzo della CPU della mia applicazione, o è il calcolo della CPU uso di iOS?
    • Ciao Markus, questa funzione restituisce l’utilizzo della CPU di applicazione.
    • Penso che il vm_deallocate non è corretto. Certamente in Swift 4 il modo corretto per chiamare sarebbe vm_deallocate(mach_task_self_, vm_address_t(bitPattern: thread_list), vm_size_t(Int(thread_count) * MemoryLayout<thread_t>.stride) ) Accesso thread_list.pointee restituisce il primo valore di thread_list, non l’indirizzo dell’array stesso.
  3. 0

    Provare questo:

    - (NSString *)cpuUsage
    {
       kern_return_t kr;
       task_info_data_t tinfo;
       mach_msg_type_number_t task_info_count;
    
       task_info_count = TASK_INFO_MAX;
       kr = task_info(mach_task_self(), TASK_BASIC_INFO, (task_info_t)tinfo, &task_info_count);
       if (kr != KERN_SUCCESS)
       {
         return @"NA";
       }
    
       task_basic_info_t      basic_info;
       thread_array_t         thread_list;
       mach_msg_type_number_t thread_count;
       thread_info_data_t     thinfo;
       mach_msg_type_number_t thread_info_count;
       thread_basic_info_t basic_info_th;
       uint32_t stat_thread = 0; //Mach threads
    
       basic_info = (task_basic_info_t)tinfo;
    
       //get threads in the task
       kr = task_threads(mach_task_self(), &thread_list, &thread_count);
       if (kr != KERN_SUCCESS)
       {
          return @"NA";
       }
       if (thread_count > 0)
        stat_thread += thread_count;
    
       long tot_idle = 0;
       long tot_user = 0;
       long tot_kernel = 0;
       int j;
    
       for (j = 0; j < thread_count; j++)
       {
          thread_info_count = THREAD_INFO_MAX;
          kr = thread_info(thread_list[j], THREAD_BASIC_INFO,
                         (thread_info_t)thinfo, &thread_info_count);
          if (kr != KERN_SUCCESS)
          {
              return nil;
          }
    
          basic_info_th = (thread_basic_info_t)thinfo;
    
          if (basic_info_th->flags & TH_FLAGS_IDLE)
          {
              //This is idle
              tot_idle = tot_idle + basic_info_th->user_time.microseconds + basic_info_th->system_time.microseconds;
          } else {
              //This is user
              tot_user = tot_user + basic_info_th->user_time.microseconds;
    
              //This is kernel
              tot_kernel = tot_kernel + basic_info_th->system_time.microseconds;
          }
    
      } //for each thread
    
      kr = vm_deallocate(mach_task_self(), (vm_offset_t)thread_list, thread_count * sizeof(thread_t));
      assert(kr == KERN_SUCCESS);
    
      long tot_cpu = tot_idle + tot_user + tot_kernel
    
      return [NSString stringWithFormat:@"Idle: %.2f, User: %.2f, Kernel: %.2f", tot_idle/tot_cpu, tot_user/tot_cpu, tot_kernel/tot_cpu];
    }

    Tuttavia, che il metodo calcola le percentuali in base al punto di partenza di ogni processo. Se siete alla ricerca per il modo più tradizionale di calcolo di questi numeri, vedere Petesh risposta.

Lascia un commento