Почему host_statistics64() возвращает противоречивые результаты?

Question

Почему host_statistics64() возвращает противоречивые результаты?

Почему host_statistics64() в OS X 10.6.8 (я не знаю, есть ли другие проблемы с этой проблемой) возвращает счетчики для свободной, активной, неактивной и проводной памяти, которые не увеличивают общий объем памяти? И почему он пропускает непоследовательное количество страниц?

Следующий вывод представляет количество страниц, не классифицированных как свободные, активные, неактивные или проводные в течение десяти секунд (с выборкой примерно один раз в секунду).

Код, который производит числа выше:

#include <stdio.h>
#include <mach/mach.h>
#include <mach/vm_statistics.h>
#include <sys/types.h>
#include <sys/sysctl.h>
#include <unistd.h>
#include <string.h>

int main(int argc, char** argv) {
        struct vm_statistics64 stats;
        mach_port_t host    = mach_host_self();
        natural_t   count   = HOST_VM_INFO64_COUNT;
        natural_t   missing = 0;
        int         debug   = argc == 2 ? !strcmp(argv[1], "-v") : 0;
        kern_return_t ret;
        int           mib[2];
        long          ram;
        natural_t     pages;
        size_t        length;
        int           i;

        mib[0] = CTL_HW;
        mib[1] = HW_MEMSIZE;
        length = sizeof(long);
        sysctl(mib, 2, &ram, &length, NULL, 0);
        pages  = ram / getpagesize();

        for (i = 0; i < 10; i++) {
                if ((ret = host_statistics64(host, HOST_VM_INFO64, (host_info64_t)&stats, &count)) != KERN_SUCCESS) {
                        printf("oops\n");
                        return 1;
                }

                /* updated for 10.9 */
                missing = pages - (
                        stats.free_count     +
                        stats.active_count   +
                        stats.inactive_count +
                        stats.wire_count     +
                        stats.compressor_page_count
                );

                if (debug) {
                        printf(
                                "%11d pages (# of pages)\n"
                                "%11d free_count (# of pages free) \n"
                                "%11d active_count (# of pages active) \n"
                                "%11d inactive_count (# of pages inactive) \n"
                                "%11d wire_count (# of pages wired down) \n"
                                "%11lld zero_fill_count (# of zero fill pages) \n"
                                "%11lld reactivations (# of pages reactivated) \n"
                                "%11lld pageins (# of pageins) \n"
                                "%11lld pageouts (# of pageouts) \n"
                                "%11lld faults (# of faults) \n"
                                "%11lld cow_faults (# of copy-on-writes) \n"
                                "%11lld lookups (object cache lookups) \n"
                                "%11lld hits (object cache hits) \n"
                                "%11lld purges (# of pages purged) \n"
                                "%11d purgeable_count (# of pages purgeable) \n"
                                "%11d speculative_count (# of pages speculative (also counted in free_count)) \n"
                                "%11lld decompressions (# of pages decompressed) \n"
                                "%11lld compressions (# of pages compressed) \n"
                                "%11lld swapins (# of pages swapped in (via compression segments)) \n"
                                "%11lld swapouts (# of pages swapped out (via compression segments)) \n"
                                "%11d compressor_page_count (# of pages used by the compressed pager to hold all the compressed data) \n"
                                "%11d throttled_count (# of pages throttled) \n"
                                "%11d external_page_count (# of pages that are file-backed (non-swap)) \n"
                                "%11d internal_page_count (# of pages that are anonymous) \n"
                                "%11lld total_uncompressed_pages_in_compressor (# of pages (uncompressed) held within the compressor.) \n",
                                pages, stats.free_count, stats.active_count, stats.inactive_count,
                                stats.wire_count, stats.zero_fill_count, stats.reactivations,
                                stats.pageins, stats.pageouts, stats.faults, stats.cow_faults,
                                stats.lookups, stats.hits, stats.purges, stats.purgeable_count,
                                stats.speculative_count, stats.decompressions, stats.compressions,
                                stats.swapins, stats.swapouts, stats.compressor_page_count,
                                stats.throttled_count, stats.external_page_count,
                                stats.internal_page_count, stats.total_uncompressed_pages_in_compressor
                        );
                }

                printf("%i\n", missing);
                sleep(1);
        }

        return 0;
}

20

macos memory darwin mach

Источник

user78259 09 фев '13 в 15:37

2 ответа

Решение

Просто заметил, что если добавить compressor_page_count в микс вы получаете гораздо ближе к фактическому объему оперативной памяти в машине.

Это наблюдение, а не объяснение, и ссылки на то, где это было должным образом задокументировано, было бы неплохо иметь!

1

Источник

user473672 01 апр '17 в 05:20

Другие вопросы по тегам macos memory darwin mach

user7070965 08 апр '17 в 20:40 2017-04-08 20:40 · Accepted Answer · 2017-04-08 20:40

TL;DR:

host_statistics64() получить информацию из разных источников, что может стоить времени и привести к противоречивым результатам.
host_statistics64() получает некоторую информацию по переменным с такими именами, как vm_page_foo_count, Но не все эти переменные принимаются во внимание, например, vm_page_stolen_count не является.
Хорошо известный /usr/bin/top добавляет украденные страницы к числу проводных страниц. Это показатель того, что эти страницы должны учитываться при подсчете страниц.

Заметки

Я работаю над MacOS 10.12 с Darwin Kernel Version 16.5.0 xnu-3789.51.2~3/RELEASE_X86_64 x86_64, но все поведение полностью воспроизводимо.
Я собираюсь связать исходный код версии XNU, которую я использую на своей машине. Его можно найти здесь: xnu-3789.51.2.
Программа, которую вы написали, в основном такая же, как /usr/bin/vm_stat которая является просто оберткой для host_statistics64() (а также host_statistics()). Соответствующий исходный код можно найти здесь: system_cmds-496 / vm_stat.tproj / vm_stat.c.

Как host_statistics64() вписывается в XNU и как это работает?

Как известно Видли, ядро OS X называется XNU (X NU IS N O U UIX) и "представляет собой гибридное ядро, объединяющее ядро Маха, разработанное в Университете Карнеги-Меллона, с компонентами из FreeBSD и C++ API для написания драйверов под названием IOKit". ( https://github.com/opensource-apple/xnu/blob/10.12/README.md)

Управление виртуальной памятью (VM) является частью Mach, поэтому host_statistics64() находится здесь. Давайте подробнее рассмотрим его реализацию, которая содержится в xnu-3789.51.2 / osfmk / kern / host.c.

Подпись функции

kern_return_t
host_statistics64(host_t host, host_flavor_t flavor, host_info64_t info, mach_msg_type_number_t * count);

Первые соответствующие строки

[...]
processor_t processor;
vm_statistics64_t stat;
vm_statistics64_data_t host_vm_stat;
mach_msg_type_number_t original_count;
unsigned int local_q_internal_count;
unsigned int local_q_external_count;
[...]
processor = processor_list;
stat = &PROCESSOR_DATA(processor, vm_stat);
host_vm_stat = *stat;

if (processor_count > 1) {
    simple_lock(&processor_list_lock);

    while ((processor = processor->processor_list) != NULL) {
        stat = &PROCESSOR_DATA(processor, vm_stat);

        host_vm_stat.zero_fill_count += stat->zero_fill_count;
        host_vm_stat.reactivations += stat->reactivations;
        host_vm_stat.pageins += stat->pageins;
        host_vm_stat.pageouts += stat->pageouts;
        host_vm_stat.faults += stat->faults;
        host_vm_stat.cow_faults += stat->cow_faults;
        host_vm_stat.lookups += stat->lookups;
        host_vm_stat.hits += stat->hits;
        host_vm_stat.compressions += stat->compressions;
        host_vm_stat.decompressions += stat->decompressions;
        host_vm_stat.swapins += stat->swapins;
        host_vm_stat.swapouts += stat->swapouts;
    }

    simple_unlock(&processor_list_lock);
}
[...]

Мы получаем host_vm_stat который имеет тип vm_statistics64_data_t, Это просто typedef struct vm_statistics64 как вы можете видеть в https://opensource.apple.com/source/xnu/xnu-3789.51.2/osfmk/mach/vm_statistics.h.auto.html. И мы получаем информацию о процессоре от Макро PROCESSOR_DATA() определено в https://opensource.apple.com/source/xnu/xnu-3789.51.2/osfmk/kern/processor_data.h.auto.html. Мы заполняем host_vm_stat просматривая все наши процессоры, просто складывая соответствующие числа.

Как вы можете видеть, мы находим некоторые хорошо известные статистические данные, такие как zero_fill_count или же compressions но не все охвачены host_statistics64(),

Следующие соответствующие строки:

stat = (vm_statistics64_t)info;

stat->free_count = vm_page_free_count + vm_page_speculative_count;
stat->active_count = vm_page_active_count;
[...]
stat->inactive_count = vm_page_inactive_count;
stat->wire_count = vm_page_wire_count + vm_page_throttled_count + vm_lopage_free_count;
stat->zero_fill_count = host_vm_stat.zero_fill_count;
stat->reactivations = host_vm_stat.reactivations;
stat->pageins = host_vm_stat.pageins;
stat->pageouts = host_vm_stat.pageouts;
stat->faults = host_vm_stat.faults;
stat->cow_faults = host_vm_stat.cow_faults;
stat->lookups = host_vm_stat.lookups;
stat->hits = host_vm_stat.hits;

stat->purgeable_count = vm_page_purgeable_count;
stat->purges = vm_page_purged_count;

stat->speculative_count = vm_page_speculative_count;

Мы повторно используем stat и сделайте это нашей структурой вывода. Затем мы заполняем free_count с суммой двух unsigned long называется vm_page_free_count а также vm_page_speculative_count, Остальные данные мы собираем аналогичным образом (используя переменные vm_page_foo_count) или взяв статистику из host_vm_stat который мы заполнили выше.

1. Заключение Мы собираем данные из разных источников. Либо из информации о процессоре, либо из переменных, называемых vm_page_foo_count, Это требует времени и может привести к некоторому несоответствию, потому что VM - очень быстрый и непрерывный процесс.

Давайте внимательнее посмотрим на уже упомянутые переменные vm_page_foo_count, Они определены в xnu-3789.51.2 / osfmk / vm / vm_page.h следующим образом:

extern
unsigned int    vm_page_free_count; /* How many pages are free? (sum of all colors) */
extern
unsigned int    vm_page_active_count;   /* How many pages are active? */
extern
unsigned int    vm_page_inactive_count; /* How many pages are inactive? */
#if CONFIG_SECLUDED_MEMORY
extern
unsigned int    vm_page_secluded_count; /* How many pages are secluded? */
extern
unsigned int    vm_page_secluded_count_free;
extern
unsigned int    vm_page_secluded_count_inuse;
#endif /* CONFIG_SECLUDED_MEMORY */
extern
unsigned int    vm_page_cleaned_count; /* How many pages are in the clean queue? */
extern
unsigned int    vm_page_throttled_count;/* How many inactives are throttled */
extern
unsigned int    vm_page_speculative_count;  /* How many speculative pages are unclaimed? */
extern unsigned int vm_page_pageable_internal_count;
extern unsigned int vm_page_pageable_external_count;
extern
unsigned int    vm_page_xpmapped_external_count;    /* How many pages are mapped executable? */
extern
unsigned int    vm_page_external_count; /* How many pages are file-backed? */
extern
unsigned int    vm_page_internal_count; /* How many pages are anonymous? */
extern
unsigned int    vm_page_wire_count;     /* How many pages are wired? */
extern
unsigned int    vm_page_wire_count_initial; /* How many pages wired at startup */
extern
unsigned int    vm_page_free_target;    /* How many do we want free? */
extern
unsigned int    vm_page_free_min;   /* When to wakeup pageout */
extern
unsigned int    vm_page_throttle_limit; /* When to throttle new page creation */
extern
uint32_t    vm_page_creation_throttle;  /* When to throttle new page creation */
extern
unsigned int    vm_page_inactive_target;/* How many do we want inactive? */
#if CONFIG_SECLUDED_MEMORY
extern
unsigned int    vm_page_secluded_target;/* How many do we want secluded? */
#endif /* CONFIG_SECLUDED_MEMORY */
extern
unsigned int    vm_page_anonymous_min;  /* When it's ok to pre-clean */
extern
unsigned int    vm_page_inactive_min;   /* When to wakeup pageout */
extern
unsigned int    vm_page_free_reserved;  /* How many pages reserved to do pageout */
extern
unsigned int    vm_page_throttle_count; /* Count of page allocations throttled */
extern
unsigned int    vm_page_gobble_count;
extern
unsigned int    vm_page_stolen_count;   /* Count of stolen pages not acccounted in zones */
[...]
extern
unsigned int    vm_page_purgeable_count;/* How many pages are purgeable now ? */
extern
unsigned int    vm_page_purgeable_wired_count;/* How many purgeable pages are wired now ? */
extern
uint64_t    vm_page_purged_count;   /* How many pages got purged so far ? */

Это много статистики о том, что мы получаем доступ только к очень ограниченному количеству, используя host_statistics64(), Большая часть этой статистики обновлена в xnu-3789.51.2 / osfmk / vm / vm_resident.c. Например, эта функция выпускает страницы в список бесплатных страниц:

/*
*   vm_page_release:
*
*   Return a page to the free list.
*/

void
vm_page_release(
    vm_page_t   mem,
    boolean_t   page_queues_locked)
{
    [...]
    vm_page_free_count++;
    [...]
}

Очень интересно extern unsigned int vm_page_stolen_count; /* Count of stolen pages not acccounted in zones */, Что такое украденные страницы? Похоже, что существуют механизмы для удаления страницы из некоторых списков, даже если она обычно не выгружается. Одним из таких механизмов является возраст страницы в спекулятивном списке страниц. xnu-3789.51.2 / osfmk / vm / vm_page.h сообщает нам

* VM_PAGE_MAX_SPECULATIVE_AGE_Q * VM_PAGE_SPECULATIVE_Q_AGE_MS
* defines the amount of time a speculative page is normally
* allowed to live in the 'protected' state (i.e. not available
* to be stolen if vm_pageout_scan is running and looking for
* pages)...  however, if the total number of speculative pages
* in the protected state exceeds our limit (defined in vm_pageout.c)
* and there are none available in VM_PAGE_SPECULATIVE_AGED_Q, then
* vm_pageout_scan is allowed to steal pages from the protected
* bucket even if they are underage.
*
* vm_pageout_scan is also allowed to pull pages from a protected
* bin if the bin has reached the "age of consent" we've set

Это точно void vm_pageout_scan(void) это увеличивает vm_page_stolen_count, Соответствующий исходный код вы найдете в xnu-3789.51.2 / osfmk / vm / vm_pageout.c.

Я думаю, что украденные страницы не учитываются при расчете статистики ВМ host_statistics64() делает.

Доказательство того, что я прав

Лучший способ доказать это - скомпилировать XNU с настроенной версией host_statistics64() рукой. У меня не было возможности сделать это, но скоро попробую.

К счастью, мы не единственные, кто заинтересован в правильной статистике ВМ. Поэтому мы должны взглянуть на реализацию хорошо известно /usr/bin/top (не содержится в XNU), который полностью доступен здесь: top-108 (я только что выбрал релиз macOS 10.12.4).

Давайте посмотрим на top-108 / libtop.c, где мы находим следующее:

static int
libtop_tsamp_update_vm_stats(libtop_tsamp_t* tsamp) {
    kern_return_t kr;
    tsamp->p_vm_stat = tsamp->vm_stat;

    mach_msg_type_number_t count = sizeof(tsamp->vm_stat) / sizeof(natural_t);
    kr = host_statistics64(libtop_port, HOST_VM_INFO64, (host_info64_t)&tsamp->vm_stat, &count);
    if (kr != KERN_SUCCESS) {
        return kr;
    }

    if (tsamp->pages_stolen > 0) {
        tsamp->vm_stat.wire_count += tsamp->pages_stolen;
    }

    [...]

    return kr;
}

tsamp имеет тип libtop_tsamp_t которая является структурой, определенной в top-108 / libtop.h. Он содержит среди прочего vm_statistics64_data_t vm_stat а также uint64_t pages_stolen,

Как вы видете, static int libtop_tsamp_update_vm_stats(libtop_tsamp_t* tsamp) получает tsamp->vm_stat заполнены host_statistics64() как мы это знаем. После этого он проверяет, tsamp->pages_stolen > 0 и добавляет его к wire_count поле tsamp->vm_stat,

2. Заключение Мы не получим количество украденных страниц, если будем просто использовать host_statistics64() как в /usr/bin/vm_stat или ваш пример кода!

Почему host_statistics64() реализовано как есть?

Честно говоря, я не знаю. Пейджинг - это сложный процесс, поэтому наблюдение в режиме реального времени является сложной задачей. Мы должны заметить, что в его реализации, похоже, нет ошибок. Я думаю, что мы бы даже не получили 100% точное количество страниц, если бы мы могли получить доступ к vm_page_stolen_count, Реализация /usr/bin/top не считает украденные страницы, если их число не очень большое.

Еще одна интересная вещь - это комментарий над функцией static void update_pages_stolen(libtop_tsamp_t *tsamp) который /* This is for <rdar://problem/6410098>. */, Open Radar - это сайт сообщений об ошибках для программного обеспечения Apple, который обычно классифицирует ошибки в формате, указанном в комментарии. Я не смог найти связанную ошибку; возможно это было о пропущенных страницах.

Я надеюсь, что эта информация может вам немного помочь. Если мне удастся скомпилировать последнюю (и настроенную) версию XNU на моей машине, я дам вам знать. Может быть, это приносит интересные идеи.