Bagaimana cara menentukan konsumsi CPU dan memori dari dalam suatu proses?

593

Saya pernah memiliki tugas untuk menentukan parameter kinerja berikut dari dalam aplikasi yang sedang berjalan:

  • Total memori virtual tersedia
  • Memori virtual saat ini digunakan
  • Memori virtual saat ini digunakan oleh proses saya
  • Total RAM tersedia
  • RAM saat ini digunakan
  • RAM saat ini digunakan oleh proses saya
  • % CPU saat ini digunakan
  • % CPU saat ini digunakan oleh proses saya

Kode harus dijalankan di Windows dan Linux. Meskipun ini tampaknya menjadi tugas standar, menemukan informasi yang diperlukan dalam manual (WIN32 API, GNU docs) serta di Internet membutuhkan waktu beberapa hari, karena ada begitu banyak informasi yang tidak lengkap / tidak benar / ketinggalan zaman mengenai topik ini menjadi ditemukan di sana.

Untuk menyelamatkan orang lain dari mengalami masalah yang sama, saya pikir itu akan menjadi ide yang baik untuk mengumpulkan semua informasi yang tersebar ditambah apa yang saya temukan dengan coba-coba di sini di satu tempat.

c++  c  memory  cpu 
— Lanzelot
sumber
13
"Total memori virtual yang tersedia" tidak ada artinya pada sistem operasi modern.
— David Schwartz
29
Mengapa itu tidak ada artinya? Apakah itu membatalkan jawaban di sini? stackoverflow.com/questions/3296211/… ... tolong jangan tinggalkan bahaya cliff saat berkomentar, ini bukan acara TV.
— Mindaugas Bernatavičius
3
@ MindaugasBernatavičius: Pertanyaan yang ditautkan adalah tentang "total memori fisik", yang merupakan fakta perangkat keras yang diketahui oleh OS. Anda mendapatkan total dengan menambahkan ukuran semua modul memori. "Total memori virtual tersedia", di sisi lain, apa artinya itu? Apakah itu ruang alamat virtual gabungan dari semua proses yang secara teoritis dapat dibuat? Angka itu akan menjadi sekitar 2 ^ 80 byte, jadi tentu tidak ada artinya.
— MSalters
2
@MSalters - terima kasih telah terlibat. Saya percaya bahwa menanyakan apa yang ada dalam pikiran OP jauh lebih baik dan lebih sehat daripada menyatakan bahwa ada sesuatu yang tidak ada artinya (tanpa penjelasan). Jika Anda perhatikan, jawabannya juga mengasumsikan posisi tertentu mengenai hal ini: Memori virtual = RAM + SWAP (atau PAGEFILE) - yang merupakan asumsi yang masuk akal. Dari sini kita tahu bahwa itu tidak berarti, karena ada interpretasi khusus dari istilah ini (yang, mungkin bukan yang paling teknis benar, sebuah percakapan sehari-hari) yang memiliki makna.
— Mindaugas Bernatavičius
2
@ MindaugasBernatavičius: Itu mengabaikan memori yang dipetakan file dan kode yang tidak di-paging. Linux memiliki alokasi memori yang tidak berkomitmen (tidak didukung oleh RAM atau swap) dan Windows memiliki tumpukan yang tidak berkomitmen.
— MSalters

Jawaban:

644

Windows

Beberapa nilai di atas mudah tersedia dari WIN32 API yang sesuai, saya hanya daftar di sini untuk kelengkapan. Namun, yang lain perlu diperoleh dari perpustakaan Performance Data Helper (PDH), yang sedikit "tidak intuitif" dan membutuhkan banyak percobaan dan kesalahan yang menyakitkan untuk dapat bekerja. (Setidaknya butuh beberapa saat, mungkin aku hanya sedikit bodoh ...)

Catatan: untuk kejelasan semua pengecekan kesalahan telah dihilangkan dari kode berikut. Periksa kode pengembalian ...!


  • Total Memori Virtual:

    #include "windows.h"

MEMORYSTATUSEX memInfo;
memInfo.dwLength = sizeof(MEMORYSTATUSEX);
GlobalMemoryStatusEx(&memInfo);
DWORDLONG totalVirtualMem = memInfo.ullTotalPageFile;

    Catatan: Nama "TotalPageFile" agak menyesatkan di sini. Pada kenyataannya, parameter ini memberikan "Ukuran Memori Virtual", yang merupakan ukuran file swap plus RAM yang dipasang.

  • Memori Virtual yang saat ini digunakan:

    Kode yang sama seperti pada "Total Virtual Memory" dan kemudian

    DWORDLONG virtualMemUsed = memInfo.ullTotalPageFile - memInfo.ullAvailPageFile;

  • Memori Virtual saat ini digunakan oleh proses saat ini:

    #include "windows.h"
#include "psapi.h"

PROCESS_MEMORY_COUNTERS_EX pmc;
GetProcessMemoryInfo(GetCurrentProcess(), (PROCESS_MEMORY_COUNTERS*)&pmc, sizeof(pmc));
SIZE_T virtualMemUsedByMe = pmc.PrivateUsage;



  • Total Memori Fisik (RAM):

    Kode yang sama seperti pada "Total Virtual Memory" dan kemudian

    DWORDLONG totalPhysMem = memInfo.ullTotalPhys;

  • Memori Fisik yang saat ini digunakan:

    Same code as in "Total Virtual Memory" and then

DWORDLONG physMemUsed = memInfo.ullTotalPhys - memInfo.ullAvailPhys;

  • Memori Fisik saat ini digunakan oleh proses saat ini:

    Kode yang sama seperti dalam "Memori Virtual saat ini digunakan oleh proses saat ini" dan kemudian

    SIZE_T physMemUsedByMe = pmc.WorkingSetSize;



  • CPU saat ini digunakan:

    #include "TCHAR.h"
#include "pdh.h"

static PDH_HQUERY cpuQuery;
static PDH_HCOUNTER cpuTotal;

void init(){
    PdhOpenQuery(NULL, NULL, &cpuQuery);
    // You can also use L"\\Processor(*)\\% Processor Time" and get individual CPU values with PdhGetFormattedCounterArray()
    PdhAddEnglishCounter(cpuQuery, L"\\Processor(_Total)\\% Processor Time", NULL, &cpuTotal);
    PdhCollectQueryData(cpuQuery);
}

double getCurrentValue(){
    PDH_FMT_COUNTERVALUE counterVal;

    PdhCollectQueryData(cpuQuery);
    PdhGetFormattedCounterValue(cpuTotal, PDH_FMT_DOUBLE, NULL, &counterVal);
    return counterVal.doubleValue;
}

  • CPU saat ini digunakan oleh proses saat ini:

    #include "windows.h"

static ULARGE_INTEGER lastCPU, lastSysCPU, lastUserCPU;
static int numProcessors;
static HANDLE self;

void init(){
    SYSTEM_INFO sysInfo;
    FILETIME ftime, fsys, fuser;

    GetSystemInfo(&sysInfo);
    numProcessors = sysInfo.dwNumberOfProcessors;

    GetSystemTimeAsFileTime(&ftime);
    memcpy(&lastCPU, &ftime, sizeof(FILETIME));

    self = GetCurrentProcess();
    GetProcessTimes(self, &ftime, &ftime, &fsys, &fuser);
    memcpy(&lastSysCPU, &fsys, sizeof(FILETIME));
    memcpy(&lastUserCPU, &fuser, sizeof(FILETIME));
}

double getCurrentValue(){
    FILETIME ftime, fsys, fuser;
    ULARGE_INTEGER now, sys, user;
    double percent;

    GetSystemTimeAsFileTime(&ftime);
    memcpy(&now, &ftime, sizeof(FILETIME));

    GetProcessTimes(self, &ftime, &ftime, &fsys, &fuser);
    memcpy(&sys, &fsys, sizeof(FILETIME));
    memcpy(&user, &fuser, sizeof(FILETIME));
    percent = (sys.QuadPart - lastSysCPU.QuadPart) +
        (user.QuadPart - lastUserCPU.QuadPart);
    percent /= (now.QuadPart - lastCPU.QuadPart);
    percent /= numProcessors;
    lastCPU = now;
    lastUserCPU = user;
    lastSysCPU = sys;

    return percent * 100;
}

Linux

Di Linux, pilihan yang tampak jelas pada awalnya adalah menggunakan API POSIX seperti getrusage()dll. Saya menghabiskan beberapa waktu untuk mencoba ini berfungsi, tetapi tidak pernah mendapatkan nilai yang berarti. Ketika saya akhirnya memeriksa sendiri sumber kernel, saya menemukan bahwa ternyata API ini belum sepenuhnya diimplementasikan pada kernel Linux 2.6 !?

Pada akhirnya saya mendapatkan semua nilai melalui kombinasi membaca sistem file semu /procdan panggilan kernel.

  • Total Memori Virtual:

    #include "sys/types.h"
#include "sys/sysinfo.h"

struct sysinfo memInfo;

sysinfo (&memInfo);
long long totalVirtualMem = memInfo.totalram;
//Add other values in next statement to avoid int overflow on right hand side...
totalVirtualMem += memInfo.totalswap;
totalVirtualMem *= memInfo.mem_unit;

  • Memori Virtual yang saat ini digunakan:

    Kode yang sama seperti pada "Total Virtual Memory" dan kemudian

    long long virtualMemUsed = memInfo.totalram - memInfo.freeram;
//Add other values in next statement to avoid int overflow on right hand side...
virtualMemUsed += memInfo.totalswap - memInfo.freeswap;
virtualMemUsed *= memInfo.mem_unit;

  • Memori Virtual saat ini digunakan oleh proses saat ini:

    #include "stdlib.h"
#include "stdio.h"
#include "string.h"

int parseLine(char* line){
    // This assumes that a digit will be found and the line ends in " Kb".
    int i = strlen(line);
    const char* p = line;
    while (*p <'0' || *p > '9') p++;
    line[i-3] = '\0';
    i = atoi(p);
    return i;
}

int getValue(){ //Note: this value is in KB!
    FILE* file = fopen("/proc/self/status", "r");
    int result = -1;
    char line[128];

    while (fgets(line, 128, file) != NULL){
        if (strncmp(line, "VmSize:", 7) == 0){
            result = parseLine(line);
            break;
        }
    }
    fclose(file);
    return result;
}



  • Total Memori Fisik (RAM):

    Kode yang sama seperti pada "Total Virtual Memory" dan kemudian

    long long totalPhysMem = memInfo.totalram;
//Multiply in next statement to avoid int overflow on right hand side...
totalPhysMem *= memInfo.mem_unit;

  • Memori Fisik yang saat ini digunakan:

    Kode yang sama seperti pada "Total Virtual Memory" dan kemudian

    long long physMemUsed = memInfo.totalram - memInfo.freeram;
//Multiply in next statement to avoid int overflow on right hand side...
physMemUsed *= memInfo.mem_unit;

  • Memori Fisik saat ini digunakan oleh proses saat ini:

    Ubah getValue () di "Memori Virtual yang saat ini digunakan oleh proses saat ini" sebagai berikut:

    int getValue(){ //Note: this value is in KB!
    FILE* file = fopen("/proc/self/status", "r");
    int result = -1;
    char line[128];

    while (fgets(line, 128, file) != NULL){
        if (strncmp(line, "VmRSS:", 6) == 0){
            result = parseLine(line);
            break;
        }
    }
    fclose(file);
    return result;
}



  • CPU saat ini digunakan:

    #include "stdlib.h"
#include "stdio.h"
#include "string.h"

static unsigned long long lastTotalUser, lastTotalUserLow, lastTotalSys, lastTotalIdle;

void init(){
    FILE* file = fopen("/proc/stat", "r");
    fscanf(file, "cpu %llu %llu %llu %llu", &lastTotalUser, &lastTotalUserLow,
        &lastTotalSys, &lastTotalIdle);
    fclose(file);
}

double getCurrentValue(){
    double percent;
    FILE* file;
    unsigned long long totalUser, totalUserLow, totalSys, totalIdle, total;

    file = fopen("/proc/stat", "r");
    fscanf(file, "cpu %llu %llu %llu %llu", &totalUser, &totalUserLow,
        &totalSys, &totalIdle);
    fclose(file);

    if (totalUser < lastTotalUser || totalUserLow < lastTotalUserLow ||
        totalSys < lastTotalSys || totalIdle < lastTotalIdle){
        //Overflow detection. Just skip this value.
        percent = -1.0;
    }
    else{
        total = (totalUser - lastTotalUser) + (totalUserLow - lastTotalUserLow) +
            (totalSys - lastTotalSys);
        percent = total;
        total += (totalIdle - lastTotalIdle);
        percent /= total;
        percent *= 100;
    }

    lastTotalUser = totalUser;
    lastTotalUserLow = totalUserLow;
    lastTotalSys = totalSys;
    lastTotalIdle = totalIdle;

    return percent;
}

  • CPU saat ini digunakan oleh proses saat ini:

    #include "stdlib.h"
#include "stdio.h"
#include "string.h"
#include "sys/times.h"
#include "sys/vtimes.h"

static clock_t lastCPU, lastSysCPU, lastUserCPU;
static int numProcessors;

void init(){
    FILE* file;
    struct tms timeSample;
    char line[128];

    lastCPU = times(&timeSample);
    lastSysCPU = timeSample.tms_stime;
    lastUserCPU = timeSample.tms_utime;

    file = fopen("/proc/cpuinfo", "r");
    numProcessors = 0;
    while(fgets(line, 128, file) != NULL){
        if (strncmp(line, "processor", 9) == 0) numProcessors++;
    }
    fclose(file);
}

double getCurrentValue(){
    struct tms timeSample;
    clock_t now;
    double percent;

    now = times(&timeSample);
    if (now <= lastCPU || timeSample.tms_stime < lastSysCPU ||
        timeSample.tms_utime < lastUserCPU){
        //Overflow detection. Just skip this value.
        percent = -1.0;
    }
    else{
        percent = (timeSample.tms_stime - lastSysCPU) +
            (timeSample.tms_utime - lastUserCPU);
        percent /= (now - lastCPU);
        percent /= numProcessors;
        percent *= 100;
    }
    lastCPU = now;
    lastSysCPU = timeSample.tms_stime;
    lastUserCPU = timeSample.tms_utime;

    return percent;
}

TODO: Platform Lainnya

Saya akan berasumsi, bahwa beberapa kode Linux juga berfungsi untuk Unix, kecuali untuk bagian yang membaca / proc pseudo-filesystem. Mungkin di Unix bagian-bagian ini dapat diganti dengan getrusage()dan fungsi yang serupa? Jika seseorang dengan pengetahuan Unix dapat mengedit jawaban ini dan mengisi detailnya ?!

— Lanzelot
sumber
10
Peringatan: di PdhAddCounter kueri harus dilokalisasi, jika tidak, ia hanya akan berjalan pada sistem asli-Inggris. Untuk sistem Vista / 2008 dan yang lebih baru, lebih suka menggunakan PdhAddEnglishCounter untuk menghindari masalah lokalisasi.
— moala
2
@NunoAniceto Saat menggunakan PROCESS_MEMORY_COUNTERS, bagaimana Anda mengambil "Memori Virtual yang saat ini digunakan oleh proses saat ini"? PrivateUsagebukan anggota PROCESS_MEMORY_COUNTERSkesalahan kompilator yang saya terima!
— CinCout
2
Mengapa Anda menggunakan "quotes like these"untuk menyertakan header sistem?
— Lightness Races in Orbit
8
@CinCout Anda membutuhkan casting .. ganti GetProcessMemoryInfo (GetCurrentProcess (), & pmc, sizeof (pmc)); dengan GetProcessMemoryInfo (GetCurrentProcess (), (PROCESS_MEMORY_COUNTERS *) & pmc, sizeof (pmc));
— Sumia
3
@ Lanzelot Sejak, kita jauh di atas Linux Kernel 3.0. Bisakah Anda memperbarui jawaban Linux Anda ke POSIX API? Jika mungkin memperbaiki Jawaban Windows juga dengan mengganti GetProcessMemoryInfo(GetCurrentProcess(), &pmc, sizeof(pmc));denganGetProcessMemoryInfo(GetCurrentProcess(), (PROCESS_MEMORY_COUNTERS*)&pmc, sizeof(pmc));
— Dr. Xperience
140

Mac OS X

Saya berharap untuk menemukan informasi serupa untuk Mac OS X juga. Karena tidak ada di sini, saya pergi dan menggali sendiri. Inilah beberapa hal yang saya temukan. Jika ada yang punya saran lain, saya ingin mendengarnya.

Total Memori Virtual

Yang ini rumit pada Mac OS X karena tidak menggunakan partisi swap atau file seperti Linux. Berikut ini entri dari dokumentasi Apple:

Catatan: Tidak seperti kebanyakan sistem operasi berbasis Unix, Mac OS X tidak menggunakan partisi swap yang telah dialokasikan sebelumnya untuk memori virtual. Sebagai gantinya, ia menggunakan semua ruang yang tersedia pada partisi boot mesin.

Jadi, jika Anda ingin tahu berapa banyak memori virtual yang masih tersedia, Anda perlu mendapatkan ukuran partisi root. Anda dapat melakukannya seperti ini:

struct statfs stats;
if (0 == statfs("/", &stats))
{
    myFreeSwap = (uint64_t)stats.f_bsize * stats.f_bfree;
}

Total Virtual Saat Ini Digunakan

Memanggil systcl dengan tombol "vm.swapusage" memberikan informasi menarik tentang penggunaan swap:

sysctl -n vm.swapusage
vm.swapusage: total = 3072.00M  used = 2511.78M  free = 560.22M  (encrypted)

Bukan berarti total penggunaan swap yang ditampilkan di sini dapat berubah jika diperlukan lebih banyak swap seperti yang dijelaskan pada bagian di atas. Jadi total sebenarnya adalah total swap saat ini . Dalam C ++, data ini dapat dikueri dengan cara ini:

xsw_usage vmusage = {0};
size_t size = sizeof(vmusage);
if( sysctlbyname("vm.swapusage", &vmusage, &size, NULL, 0)!=0 )
{
   perror( "unable to get swap usage by calling sysctlbyname(\"vm.swapusage\",...)" );
}

Perhatikan bahwa "xsw_usage", dinyatakan dalam sysctl.h, tampaknya tidak didokumentasikan dan saya menduga ada cara yang lebih portabel untuk mengakses nilai-nilai ini.

Memori Virtual Saat Ini Digunakan oleh Proses saya

Anda bisa mendapatkan statistik tentang proses Anda saat ini menggunakan task_infofungsi. Itu termasuk ukuran penduduk saat ini dari proses Anda dan ukuran virtual saat ini.

#include<mach/mach.h>

struct task_basic_info t_info;
mach_msg_type_number_t t_info_count = TASK_BASIC_INFO_COUNT;

if (KERN_SUCCESS != task_info(mach_task_self(),
                              TASK_BASIC_INFO, (task_info_t)&t_info, 
                              &t_info_count))
{
    return -1;
}
// resident size is in t_info.resident_size;
// virtual size is in t_info.virtual_size;

Total RAM tersedia

Jumlah RAM fisik yang tersedia di sistem Anda tersedia menggunakan sysctlfungsi sistem seperti ini:

#include <sys/types.h>
#include <sys/sysctl.h>
...
int mib[2];
int64_t physical_memory;
mib[0] = CTL_HW;
mib[1] = HW_MEMSIZE;
length = sizeof(int64_t);
sysctl(mib, 2, &physical_memory, &length, NULL, 0);

RAM Saat Ini Digunakan

Anda bisa mendapatkan statistik memori umum dari host_statisticsfungsi sistem.

#include <mach/vm_statistics.h>
#include <mach/mach_types.h>
#include <mach/mach_init.h>
#include <mach/mach_host.h>

int main(int argc, const char * argv[]) {
    vm_size_t page_size;
    mach_port_t mach_port;
    mach_msg_type_number_t count;
    vm_statistics64_data_t vm_stats;

    mach_port = mach_host_self();
    count = sizeof(vm_stats) / sizeof(natural_t);
    if (KERN_SUCCESS == host_page_size(mach_port, &page_size) &&
        KERN_SUCCESS == host_statistics64(mach_port, HOST_VM_INFO,
                                        (host_info64_t)&vm_stats, &count))
    {
        long long free_memory = (int64_t)vm_stats.free_count * (int64_t)page_size;

        long long used_memory = ((int64_t)vm_stats.active_count +
                                 (int64_t)vm_stats.inactive_count +
                                 (int64_t)vm_stats.wire_count) *  (int64_t)page_size;
        printf("free memory: %lld\nused memory: %lld\n", free_memory, used_memory);
    }

    return 0;
}

Satu hal yang perlu diperhatikan di sini adalah bahwa ada lima jenis halaman memori di Mac OS X. Mereka adalah sebagai berikut:

  1. Halaman berkabel yang terkunci pada tempatnya dan tidak dapat ditukar
  2. Halaman aktif yang memuat ke memori fisik dan akan relatif sulit untuk ditukar
  3. Halaman tidak aktif yang dimuat ke dalam memori, tetapi belum digunakan baru-baru ini dan bahkan mungkin tidak diperlukan sama sekali. Ini adalah kandidat potensial untuk bertukar. Memori ini mungkin perlu dibilas.
  4. Cache halaman yang telah beberapa bagaimana cache yang kemungkinan akan dengan mudah digunakan kembali. Memori yang di-cache mungkin tidak akan membutuhkan pembilasan. Masih mungkin untuk halaman yang di-cache diaktifkan kembali
  5. Halaman gratis yang sepenuhnya gratis dan siap digunakan.

Adalah baik untuk dicatat bahwa hanya karena Mac OS X dapat menunjukkan sangat sedikit memori bebas aktual pada waktu itu mungkin bukan indikasi yang baik tentang seberapa banyak yang siap digunakan dalam waktu singkat.

RAM Saat Ini Digunakan oleh Proses saya

Lihat "Memori Virtual Saat Ini Digunakan oleh Proses Saya" di atas. Kode yang sama berlaku.

— Michael Taylor
sumber
Anda tinggalkan #sertakan <mach / mach.h> untuk mendefinisikan task_info () di bagian "Memori Virtual Saat Ini Digunakan oleh Proses Saya". Header ini perlu dimasukkan untuk mendefinisikan fungsi itu.
— Dan Nissenbaum
4
Adakah ide tentang penggunaan CPU?
— Mihir Mehta
@ Michael Taylor, Ini bagus, terima kasih, tetapi pertanyaan tentang RAM yang saat ini digunakan untuk OS X, tampaknya Anda mendapatkan statistik VM, bukan memori fisik. Apakah itu yang sebenarnya terjadi di sini?
— Edgar Aroutiounian
1
Bagaimana kita bisa menghitung memori aplikasi dan cache Memori seperti monitor aktivitas? Saya menggunakan vm_stats.inactive_page_count * page_size untuk menghitung Cache FIle tetapi tidak disinkronkan dengan Monitor aktivitas. Terima kasih sebelumnya
— Amit Khandelwal
1
penulis asli tampaknya bingung tentang "memori virtual" - dalam beberapa konteks ini tidak mengacu pada memori swapped-to-disk, melainkan ruang alamat virtual, yang mungkin tidak sepenuhnya paged-in. Temukan sistem yang tidak menggunakan swap apa pun, dan Anda akan melihat bahwa sebagian besar proses memiliki ukuran "virt" yang lebih besar daripada ukuran "rss". Di bagian "Memori Virtual Saat Ini Digunakan oleh Proses saya", itulah yang disebut "memori virtual" - ruang alamat, bukan memori swap-ke-disk.
— Pierce
63

Linux

Di Linux, informasi ini tersedia di sistem file / proc. Saya bukan penggemar format file teks yang digunakan, karena setiap distribusi Linux tampaknya mengkustomisasi setidaknya satu file penting. Pandangan cepat ketika sumber ke 'ps' mengungkapkan kekacauan.

Tetapi di sinilah tempat mencari informasi yang Anda cari:

/ proc / meminfo berisi sebagian besar informasi seluruh sistem yang Anda cari. Di sini sepertinya di sistem saya; Saya pikir Anda tertarik pada MemTotal , MemFree , SwapTotal , dan SwapFree :

Anderson cxc # more /proc/meminfo
MemTotal:      4083948 kB
MemFree:       2198520 kB
Buffers:         82080 kB
Cached:        1141460 kB
SwapCached:          0 kB
Active:        1137960 kB
Inactive:       608588 kB
HighTotal:     3276672 kB
HighFree:      1607744 kB
LowTotal:       807276 kB
LowFree:        590776 kB
SwapTotal:     2096440 kB
SwapFree:      2096440 kB
Dirty:              32 kB
Writeback:           0 kB
AnonPages:      523252 kB
Mapped:          93560 kB
Slab:            52880 kB
SReclaimable:    24652 kB
SUnreclaim:      28228 kB
PageTables:       2284 kB
NFS_Unstable:        0 kB
Bounce:              0 kB
CommitLimit:   4138412 kB
Committed_AS:  1845072 kB
VmallocTotal:   118776 kB
VmallocUsed:      3964 kB
VmallocChunk:   112860 kB
HugePages_Total:     0
HugePages_Free:      0
HugePages_Rsvd:      0
Hugepagesize:     2048 kB

Untuk pemanfaatan CPU, Anda harus melakukan sedikit pekerjaan. Linux menyediakan keseluruhan pemanfaatan CPU sejak sistem dimulai; ini mungkin bukan yang Anda minati. Jika Anda ingin tahu pemanfaatan CPU untuk detik terakhir, atau 10 detik, maka Anda perlu menanyakan informasi dan menghitungnya sendiri.

Informasi ini tersedia di / proc / stat , yang didokumentasikan dengan cukup baik di http://www.linuxhowtos.org/System/procstat.htm ; di sini seperti apa kotak 4-core saya:

Anderson cxc #  more /proc/stat
cpu  2329889 0 2364567 1063530460 9034 9463 96111 0
cpu0 572526 0 636532 265864398 2928 1621 6899 0
cpu1 590441 0 531079 265949732 4763 351 8522 0
cpu2 562983 0 645163 265796890 682 7490 71650 0
cpu3 603938 0 551790 265919440 660 0 9040 0
intr 37124247
ctxt 50795173133
btime 1218807985
processes 116889
procs_running 1
procs_blocked 0

Pertama, Anda perlu menentukan berapa banyak CPU (atau prosesor, atau inti proses) yang tersedia di sistem. Untuk melakukan ini, hitung jumlah entri 'cpuN', di mana N dimulai pada 0 dan kenaikan. Jangan hitung baris 'cpu', yang merupakan kombinasi dari baris cpuN. Dalam contoh saya, Anda dapat melihat cpu0 hingga cpu3, ​​dengan total 4 prosesor. Mulai sekarang, Anda dapat mengabaikan cpu0..cpu3, ​​dan fokus hanya pada baris 'cpu'.

Selanjutnya, Anda perlu tahu bahwa angka keempat di baris ini adalah ukuran waktu idle, dan dengan demikian angka keempat pada baris 'cpu' adalah total waktu idle untuk semua prosesor sejak waktu boot. Waktu ini diukur dalam Linux "jiffies", yang masing-masing 1/100 detik.

Tetapi Anda tidak peduli dengan total waktu idle; Anda peduli dengan waktu idle dalam periode tertentu, misalnya detik terakhir. Apakah menghitung itu, Anda perlu membaca file ini dua kali, terpisah 1 detik. Kemudian Anda dapat melakukan perbedaan dari nilai keempat baris. Misalnya, jika Anda mengambil sampel dan mendapatkan:

cpu  2330047 0 2365006 1063853632 9035 9463 96114 0

Kemudian satu detik kemudian Anda mendapatkan sampel ini:

cpu  2330047 0 2365007 1063854028 9035 9463 96114 0

Kurangi dua angka, dan Anda mendapatkan perbedaan 396, yang berarti bahwa CPU Anda menganggur selama 3,96 detik dari 1,00 detik terakhir. Triknya, tentu saja, adalah Anda harus membaginya dengan jumlah prosesor. 3,96 / 4 = 0,99, dan ada persentase idle Anda; 99% menganggur, dan 1% sibuk.

Dalam kode saya, saya memiliki buffer cincin 360 entri, dan saya membaca file ini setiap detik. Itu memungkinkan saya dengan cepat menghitung pemanfaatan CPU selama 1 detik, 10 detik, dll., Hingga 1 jam.

Untuk informasi spesifik proses, Anda harus melihat di / proc / pid ; jika Anda tidak peduli dengan pid Anda, Anda dapat melihat / proc / self.

CPU yang digunakan oleh proses Anda tersedia di / proc / self / stat . Ini adalah file yang tampak aneh yang terdiri dari satu baris; sebagai contoh:

19340 (whatever) S 19115 19115 3084 34816 19115 4202752 118200 607 0 0 770 384 2
 7 20 0 77 0 266764385 692477952 105074 4294967295 134512640 146462952 321468364
8 3214683328 4294960144 0 2147221247 268439552 1276 4294967295 0 0 17 0 0 0 0

Data penting di sini adalah token ke-13 dan ke-14 (0 dan 770 di sini). Token ke-13 adalah jumlah jiffies yang telah dieksekusi proses dalam mode pengguna, dan yang ke-14 adalah jumlah jiffies yang telah dieksekusi proses dalam mode kernel. Tambahkan keduanya bersamaan, dan Anda memiliki utilisasi CPU total.

Sekali lagi, Anda harus mengambil sampel file ini secara berkala, dan menghitung perbedaannya, untuk menentukan penggunaan CPU dari waktu ke waktu.

Sunting: ingat bahwa ketika Anda menghitung pemanfaatan CPU proses Anda, Anda harus mempertimbangkan 1) jumlah utas dalam proses Anda, dan 2) jumlah prosesor dalam sistem. Misalnya, jika proses single-threaded Anda hanya menggunakan 25% dari CPU, itu bisa baik atau buruk. Baik pada sistem prosesor tunggal, tetapi buruk pada sistem prosesor 4; ini berarti bahwa proses Anda berjalan terus-menerus, dan menggunakan 100% siklus CPU yang tersedia untuknya.

Untuk informasi memori khusus proses, Anda harus melihat / proc / self / status, yang terlihat seperti ini:

Name:   whatever
State:  S (sleeping)
Tgid:   19340
Pid:    19340
PPid:   19115
TracerPid:      0
Uid:    0       0       0       0
Gid:    0       0       0       0
FDSize: 256
Groups: 0 1 2 3 4 6 10 11 20 26 27
VmPeak:   676252 kB
VmSize:   651352 kB
VmLck:         0 kB
VmHWM:    420300 kB
VmRSS:    420296 kB
VmData:   581028 kB
VmStk:       112 kB
VmExe:     11672 kB
VmLib:     76608 kB
VmPTE:      1244 kB
Threads:        77
SigQ:   0/36864
SigPnd: 0000000000000000
ShdPnd: 0000000000000000
SigBlk: fffffffe7ffbfeff
SigIgn: 0000000010001000
SigCgt: 20000001800004fc
CapInh: 0000000000000000
CapPrm: 00000000ffffffff
CapEff: 00000000fffffeff
Cpus_allowed:   0f
Mems_allowed:   1
voluntary_ctxt_switches:        6518
nonvoluntary_ctxt_switches:     6598

Entri yang dimulai dengan 'Vm' adalah yang menarik:

  • VmPeak adalah ruang memori virtual maksimum yang digunakan oleh proses, dalam kB (1024 byte).
  • VmSize adalah ruang memori virtual saat ini yang digunakan oleh proses, dalam kB. Dalam contoh saya, ini cukup besar: 651.352 kB, atau sekitar 636 megabita.
  • VmRss adalah jumlah memori yang telah dipetakan ke dalam ruang alamat proses, atau ukuran set residennya. Ini jauh lebih kecil (420.296 kB, atau sekitar 410 megabita). Perbedaannya: program saya telah memetakan 636 MB melalui mmap (), tetapi hanya mengakses 410 MB, dan karenanya hanya 410 MB halaman yang telah ditetapkan untuknya.

Satu-satunya item yang saya tidak yakin tentang Swapspace saat ini digunakan oleh proses saya . Saya tidak tahu apakah ini tersedia.

— Martin Del Vecchio
sumber
1
Terima kasih Martin, jika saya memiliki semua informasi ini dikumpulkan di satu tempat, itu akan menyelamatkan saya beberapa malam tanpa tidur ... Namun, untuk CPU dari proses saat ini saya pikir fungsi times () adalah pendekatan yang lebih mudah dan lebih dapat diandalkan. BTW: Swapspace dari proses saat ini = VmSize - VmRSS, bukan?
— Lanzelot
14

di windows Anda bisa mendapatkan penggunaan CPU dengan kode di bawah ini:

#include <windows.h>
#include <stdio.h>

    //------------------------------------------------------------------------------------------------------------------
    // Prototype(s)...
    //------------------------------------------------------------------------------------------------------------------
    CHAR cpuusage(void);

    //-----------------------------------------------------
    typedef BOOL ( __stdcall * pfnGetSystemTimes)( LPFILETIME lpIdleTime, LPFILETIME lpKernelTime, LPFILETIME lpUserTime );
    static pfnGetSystemTimes s_pfnGetSystemTimes = NULL;

    static HMODULE s_hKernel = NULL;
    //-----------------------------------------------------
    void GetSystemTimesAddress()
    {
        if( s_hKernel == NULL )
        {   
            s_hKernel = LoadLibrary( L"Kernel32.dll" );
            if( s_hKernel != NULL )
            {
                s_pfnGetSystemTimes = (pfnGetSystemTimes)GetProcAddress( s_hKernel, "GetSystemTimes" );
                if( s_pfnGetSystemTimes == NULL )
                {
                    FreeLibrary( s_hKernel ); s_hKernel = NULL;
                }
            }
        }
    }
    //----------------------------------------------------------------------------------------------------------------

    //----------------------------------------------------------------------------------------------------------------
    // cpuusage(void)
    // ==============
    // Return a CHAR value in the range 0 - 100 representing actual CPU usage in percent.
    //----------------------------------------------------------------------------------------------------------------
    CHAR cpuusage()
    {
        FILETIME               ft_sys_idle;
        FILETIME               ft_sys_kernel;
        FILETIME               ft_sys_user;

        ULARGE_INTEGER         ul_sys_idle;
        ULARGE_INTEGER         ul_sys_kernel;
        ULARGE_INTEGER         ul_sys_user;

        static ULARGE_INTEGER    ul_sys_idle_old;
        static ULARGE_INTEGER  ul_sys_kernel_old;
        static ULARGE_INTEGER  ul_sys_user_old;

        CHAR  usage = 0;

        // we cannot directly use GetSystemTimes on C language
        /* add this line :: pfnGetSystemTimes */
        s_pfnGetSystemTimes(&ft_sys_idle,    /* System idle time */
            &ft_sys_kernel,  /* system kernel time */
            &ft_sys_user);   /* System user time */

        CopyMemory(&ul_sys_idle  , &ft_sys_idle  , sizeof(FILETIME)); // Could been optimized away...
        CopyMemory(&ul_sys_kernel, &ft_sys_kernel, sizeof(FILETIME)); // Could been optimized away...
        CopyMemory(&ul_sys_user  , &ft_sys_user  , sizeof(FILETIME)); // Could been optimized away...

        usage  =
            (
            (
            (
            (
            (ul_sys_kernel.QuadPart - ul_sys_kernel_old.QuadPart)+
            (ul_sys_user.QuadPart   - ul_sys_user_old.QuadPart)
            )
            -
            (ul_sys_idle.QuadPart-ul_sys_idle_old.QuadPart)
            )
            *
            (100)
            )
            /
            (
            (ul_sys_kernel.QuadPart - ul_sys_kernel_old.QuadPart)+
            (ul_sys_user.QuadPart   - ul_sys_user_old.QuadPart)
            )
            );

        ul_sys_idle_old.QuadPart   = ul_sys_idle.QuadPart;
        ul_sys_user_old.QuadPart   = ul_sys_user.QuadPart;
        ul_sys_kernel_old.QuadPart = ul_sys_kernel.QuadPart;

        return usage;
    }
    //------------------------------------------------------------------------------------------------------------------
    // Entry point
    //------------------------------------------------------------------------------------------------------------------
    int main(void)
    {
        int n;
        GetSystemTimesAddress();
        for(n=0;n<20;n++)
        {
            printf("CPU Usage: %3d%%\r",cpuusage());
            Sleep(2000);
        }
        printf("\n");
        return 0;
    }
— sayyed mohsen zahraee
sumber
dapatkah ini dimodifikasi untuk fungsi DLL eksternal yang nantinya dapat saya hubungi di c #?
— Nico
11
Pemformatan usage =adalah hal paling kreatif yang pernah saya lihat, tidak dapat dibaca sama sekali selain kreatif
— ViRuSTriNiTy
Peringatan: ekspresi dalam kode di atas yang menghitung 'penggunaan' jauh. Jika sistem itu diam, itu akan membaginya dengan nol. Jika waktu idle sama dengan waktu pengguna + kernel, waktu tersebut akan menghasilkan 0 daripada 50% seperti yang diharapkan.
— Andrei Belogortseff
Juga perlu diingat bahwa menurut MSDN saat ini, waktu kernel juga termasuk waktu idle!
— Andrei Belogortseff
@sayyedmohsenzahraee: Saya belum melihat ke logikanya, hanya komentar pada kode itu sendiri. 1) Gunakan variabel polos 64-bit alih-alih serikat, yaitu ULONGLONGuntuk VS bukan ULARGE_INTEGER. 2) Anda terlalu rumit dengan menelepon CopyMemory(), lakukan ULONGLONG ul_sys_idle = *(ULONGLONG*)&ft_sys_idle;saja. Ini akan diterjemahkan ke dalam instruksi CPU mov(atau lea) tunggal .
— ahmd0
12

Linux

Cara portabel membaca memori dan memuat nomor adalah sysinfopanggilan

Pemakaian

   #include <sys/sysinfo.h>

   int sysinfo(struct sysinfo *info);

DESKRIPSI

   Until Linux 2.3.16, sysinfo() used to return information in the
   following structure:

       struct sysinfo {
           long uptime;             /* Seconds since boot */
           unsigned long loads[3];  /* 1, 5, and 15 minute load averages */
           unsigned long totalram;  /* Total usable main memory size */
           unsigned long freeram;   /* Available memory size */
           unsigned long sharedram; /* Amount of shared memory */
           unsigned long bufferram; /* Memory used by buffers */
           unsigned long totalswap; /* Total swap space size */
           unsigned long freeswap;  /* swap space still available */
           unsigned short procs;    /* Number of current processes */
           char _f[22];             /* Pads structure to 64 bytes */
       };

   and the sizes were given in bytes.

   Since Linux 2.3.23 (i386), 2.3.48 (all architectures) the structure
   is:

       struct sysinfo {
           long uptime;             /* Seconds since boot */
           unsigned long loads[3];  /* 1, 5, and 15 minute load averages */
           unsigned long totalram;  /* Total usable main memory size */
           unsigned long freeram;   /* Available memory size */
           unsigned long sharedram; /* Amount of shared memory */
           unsigned long bufferram; /* Memory used by buffers */
           unsigned long totalswap; /* Total swap space size */
           unsigned long freeswap;  /* swap space still available */
           unsigned short procs;    /* Number of current processes */
           unsigned long totalhigh; /* Total high memory size */
           unsigned long freehigh;  /* Available high memory size */
           unsigned int mem_unit;   /* Memory unit size in bytes */
           char _f[20-2*sizeof(long)-sizeof(int)]; /* Padding to 64 bytes */
       };

   and the sizes are given as multiples of mem_unit bytes.
— Mark Lakata
sumber
3

QNX

Karena ini seperti "wikipage of code" Saya ingin menambahkan beberapa kode dari basis Pengetahuan QNX (catatan: ini bukan pekerjaan saya, tapi saya memeriksanya dan berfungsi dengan baik di sistem saya):

Cara mendapatkan penggunaan CPU di%: http://www.qnx.com/support/knowledgebase.html?id=50130000000P9b5

#include <atomic.h>
#include <libc.h>
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/iofunc.h>
#include <sys/neutrino.h>
#include <sys/resmgr.h>
#include <sys/syspage.h>
#include <unistd.h>
#include <inttypes.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/debug.h>
#include <sys/procfs.h>
#include <sys/syspage.h>
#include <sys/neutrino.h>
#include <sys/time.h>
#include <time.h>
#include <fcntl.h>
#include <devctl.h>
#include <errno.h>

#define MAX_CPUS 32

static float Loads[MAX_CPUS];
static _uint64 LastSutime[MAX_CPUS];
static _uint64 LastNsec[MAX_CPUS];
static int ProcFd = -1;
static int NumCpus = 0;


int find_ncpus(void) {
    return NumCpus;
}

int get_cpu(int cpu) {
    int ret;
    ret = (int)Loads[ cpu % MAX_CPUS ];
    ret = max(0,ret);
    ret = min(100,ret);
    return( ret );
}

static _uint64 nanoseconds( void ) {
    _uint64 sec, usec;
    struct timeval tval;
    gettimeofday( &tval, NULL );
    sec = tval.tv_sec;
    usec = tval.tv_usec;
    return( ( ( sec * 1000000 ) + usec ) * 1000 );
}

int sample_cpus( void ) {
    int i;
    debug_thread_t debug_data;
    _uint64 current_nsec, sutime_delta, time_delta;
    memset( &debug_data, 0, sizeof( debug_data ) );

    for( i=0; i<NumCpus; i++ ) {
        /* Get the sutime of the idle thread #i+1 */
        debug_data.tid = i + 1;
        devctl( ProcFd, DCMD_PROC_TIDSTATUS,
        &debug_data, sizeof( debug_data ), NULL );
        /* Get the current time */
        current_nsec = nanoseconds();
        /* Get the deltas between now and the last samples */
        sutime_delta = debug_data.sutime - LastSutime[i];
        time_delta = current_nsec - LastNsec[i];
        /* Figure out the load */
        Loads[i] = 100.0 - ( (float)( sutime_delta * 100 ) / (float)time_delta );
        /* Flat out strange rounding issues. */
        if( Loads[i] < 0 ) {
            Loads[i] = 0;
        }
        /* Keep these for reference in the next cycle */
        LastNsec[i] = current_nsec;
        LastSutime[i] = debug_data.sutime;
    }
    return EOK;
}

int init_cpu( void ) {
    int i;
    debug_thread_t debug_data;
    memset( &debug_data, 0, sizeof( debug_data ) );
/* Open a connection to proc to talk over.*/
    ProcFd = open( "/proc/1/as", O_RDONLY );
    if( ProcFd == -1 ) {
        fprintf( stderr, "pload: Unable to access procnto: %s\n",strerror( errno ) );
        fflush( stderr );
        return -1;
    }
    i = fcntl(ProcFd,F_GETFD);
    if(i != -1){
        i |= FD_CLOEXEC;
        if(fcntl(ProcFd,F_SETFD,i) != -1){
            /* Grab this value */
            NumCpus = _syspage_ptr->num_cpu;
            /* Get a starting point for the comparisons */
            for( i=0; i<NumCpus; i++ ) {
                /*
                * the sutime of idle thread is how much
                * time that thread has been using, we can compare this
                * against how much time has passed to get an idea of the
                * load on the system.
                */
                debug_data.tid = i + 1;
                devctl( ProcFd, DCMD_PROC_TIDSTATUS, &debug_data, sizeof( debug_data ), NULL );
                LastSutime[i] = debug_data.sutime;
                LastNsec[i] = nanoseconds();
            }
            return(EOK);
        }
    }
    close(ProcFd);
    return(-1);
}

void close_cpu(void){
    if(ProcFd != -1){
        close(ProcFd);
        ProcFd = -1;
    }
}

int main(int argc, char* argv[]){
    int i,j;
    init_cpu();
    printf("System has: %d CPUs\n", NumCpus);
    for(i=0; i<20; i++) {
        sample_cpus();
        for(j=0; j<NumCpus;j++)
        printf("CPU #%d: %f\n", j, Loads[j]);
        sleep(1);
    }
    close_cpu();
}

Cara mendapatkan memori gratis (!): Http://www.qnx.com/support/knowledgebase.html?id=50130000000mlbx

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <err.h>
#include <sys/stat.h>
#include <sys/types.h>

int main( int argc, char *argv[] ){
    struct stat statbuf;
    paddr_t freemem;
    stat( "/proc", &statbuf );
    freemem = (paddr_t)statbuf.st_size;
    printf( "Free memory: %d bytes\n", freemem );
    printf( "Free memory: %d KB\n", freemem / 1024 );
    printf( "Free memory: %d MB\n", freemem / ( 1024 * 1024 ) );
    return 0;
}
— Boernii
sumber
1

Mac OS X - CPU

Penggunaan CPU secara keseluruhan:

Dari Ambil informasi sistem pada MacOS X? :

#include <mach/mach_init.h>
#include <mach/mach_error.h>
#include <mach/mach_host.h>
#include <mach/vm_map.h>

static unsigned long long _previousTotalTicks = 0;
static unsigned long long _previousIdleTicks = 0;

// Returns 1.0f for "CPU fully pinned", 0.0f for "CPU idle", or somewhere in between
// You'll need to call this at regular intervals, since it measures the load between
// the previous call and the current one.
float GetCPULoad()
{
   host_cpu_load_info_data_t cpuinfo;
   mach_msg_type_number_t count = HOST_CPU_LOAD_INFO_COUNT;
   if (host_statistics(mach_host_self(), HOST_CPU_LOAD_INFO, (host_info_t)&cpuinfo, &count) == KERN_SUCCESS)
   {
      unsigned long long totalTicks = 0;
      for(int i=0; i<CPU_STATE_MAX; i++) totalTicks += cpuinfo.cpu_ticks[i];
      return CalculateCPULoad(cpuinfo.cpu_ticks[CPU_STATE_IDLE], totalTicks);
   }
   else return -1.0f;
}

float CalculateCPULoad(unsigned long long idleTicks, unsigned long long totalTicks)
{
  unsigned long long totalTicksSinceLastTime = totalTicks-_previousTotalTicks;
  unsigned long long idleTicksSinceLastTime  = idleTicks-_previousIdleTicks;
  float ret = 1.0f-((totalTicksSinceLastTime > 0) ? ((float)idleTicksSinceLastTime)/totalTicksSinceLastTime : 0);
  _previousTotalTicks = totalTicks;
  _previousIdleTicks  = idleTicks;
  return ret;
}
— souch
sumber
0

Untuk Linux Anda juga dapat menggunakan / proc / self / statm untuk mendapatkan satu baris angka yang berisi informasi proses memori utama yang merupakan proses yang lebih cepat daripada melalui daftar panjang informasi yang dilaporkan saat Anda dapatkan dari proc / self / status

Lihat http://man7.org/linux/man-pages/man5/proc.5.html

   /proc/[pid]/statm
          Provides information about memory usage, measured in pages.
          The columns are:

              size       (1) total program size
                         (same as VmSize in /proc/[pid]/status)
              resident   (2) resident set size
                         (same as VmRSS in /proc/[pid]/status)
              shared     (3) number of resident shared pages (i.e., backed by a file)
                         (same as RssFile+RssShmem in /proc/[pid]/status)
              text       (4) text (code)
              lib        (5) library (unused since Linux 2.6; always 0)
              data       (6) data + stack
              dt         (7) dirty pages (unused since Linux 2.6; always 0)
— Steven Warner
sumber
1
Adakah yang tahu seberapa dapat diandalkan ukuran total yang dilaporkan dalam halaman? Apakah ini jejak kaki yang sebenarnya di dalam halaman?
— Niken
-1

Saya menggunakan kode berikut ini dalam proyek C ++ saya dan itu bekerja dengan baik:

static HANDLE self;
static int numProcessors;
SYSTEM_INFO sysInfo;

double percent;

numProcessors = sysInfo.dwNumberOfProcessors;

//Getting system times information
FILETIME SysidleTime;
FILETIME SyskernelTime; 
FILETIME SysuserTime; 
ULARGE_INTEGER SyskernelTimeInt, SysuserTimeInt;
GetSystemTimes(&SysidleTime, &SyskernelTime, &SysuserTime);
memcpy(&SyskernelTimeInt, &SyskernelTime, sizeof(FILETIME));
memcpy(&SysuserTimeInt, &SysuserTime, sizeof(FILETIME));
__int64 denomenator = SysuserTimeInt.QuadPart + SyskernelTimeInt.QuadPart;  

//Getting process times information
FILETIME ProccreationTime, ProcexitTime, ProcKernelTime, ProcUserTime;
ULARGE_INTEGER ProccreationTimeInt, ProcexitTimeInt, ProcKernelTimeInt, ProcUserTimeInt;
GetProcessTimes(self, &ProccreationTime, &ProcexitTime, &ProcKernelTime, &ProcUserTime);
memcpy(&ProcKernelTimeInt, &ProcKernelTime, sizeof(FILETIME));
memcpy(&ProcUserTimeInt, &ProcUserTime, sizeof(FILETIME));
__int64 numerator = ProcUserTimeInt.QuadPart + ProcKernelTimeInt.QuadPart;
//QuadPart represents a 64-bit signed integer (ULARGE_INTEGER)

percent = 100*(numerator/denomenator);
— Salman Ghaffar
sumber
Belumkah Anda mendapat nilai seperti 0,00% dan nilai, di atas 100% dengan mekanisme ini?
— Buddhika Chaturanga
Apakah ini untuk Mac OS?
— RuLoViC
@RuLoViC Ini untuk Windows.
— nonrectangular
Dengan menggunakan situs kami, Anda mengakui telah membaca dan memahami Kebijakan Cookie dan Kebijakan Privasi kami.
Licensed under cc by-sa 3.0 with attribution required.