Spec-Zone.ru › OCaml 5.0

Модуль Gc

module Gc: sig .. end

Управление памятью и статистика; окончательные значения.

type stat = {
minor_words : float; (*

Количество слов, выделенных в меньшей куче с момента запуска программы.

*)
promoted_words : float; (*

Количество слов, выделенных в меньшей куче, переживших сборку меньшей кучи и перемещённых в большую кучу с момента запуска программы.

*)
major_words : float; (*

Количество слов, выделенных в большей куче, включая продвинутые слова, с момента запуска программы.

*)
minor_collections : int; (*

Количество сборок меньшей кучи с момента запуска программы.

*)
major_collections : int; (*

Количество завершённых циклов сбора большей кучи с момента запуска программы.

*)
heap_words : int; (*

Общий размер большей кучи в словах.

*)
heap_chunks : int; (*

Количество непрерывных фрагментов памяти, составляющих большую кучу.

*)
live_words : int; (*

Количество слов активных данных в большей куче, включая заголовочные слова.

Обратите внимание, что «активные» слова относятся к каждому слову в большей куче, которое в настоящее время не известно как подлежащее сбору, что включает слова, ставшие недоступными для программы после начала предыдущего цикла gc. Обычно намного проще и предсказуемее вызвать Gc.full_major (или Gc.compact), а затем вычислять статистику gc, так как тогда «активные» слова имеют простое значение «доступные для программы». Одно замечание: однократное вызов Gc.full_major не освободит значения, у которых есть финализатор из Gc.finalise (это не относится к Gc.finalise_last). Если это замечание имеет значение, просто вызовите Gc.full_major дважды вместо одного.

*)
live_blocks : int; (*

Количество активных блоков в большей куче.

См. live_words для замечания о значении «активный».

*)
free_words : int; (*

Количество слов в свободной цепочке.

*)
free_blocks : int; (*

Количество блоков в свободной цепочке.

*)
largest_free : int; (*

Размер (в словах) самого большого блока в свободной цепочке.

*)
fragments : int; (*

Количество потерянных слов из-за фрагментации. Это свободные блоки по 1 слову, размещённые между двумя активными блоками. Они недоступны для выделения.

*)
compactions : int; (*

Количество уплотнений кучи с момента запуска программы.

*)
top_heap_words : int; (*

Максимальный размер, достигнутый большой кучей, в словах.

*)
stack_size : int; (*

Текущий размер стека в словах.

  • С 3.12.0
*)
forced_major_collections : int; (*

Количество завершённых принудительных полных сборок большей кучи с момента запуска программы.

  • С 4.12.0
*)
}

Счётчики управления памятью возвращаются в stat записи. Эти счётчики дают значения для всей программы.

Общее количество памяти, выделенной программой с момента запуска, составляет (в словах) minor_words + major_words - promoted_words. Умножьте на размер слова (4 на 32-разрядной машине, 8 на 64-разрядной машине), чтобы получить количество байтов.

type control = {
minor_heap_size : int; (*

Размер (в словах) меньшего куска памяти. Изменение этого параметра вызовет сборку мусора меньшего масштаба. Общий размер меньшего куска памяти, используемый этой программой, является суммой размеров куска памяти активных областей. По умолчанию: 256k.

*)
major_heap_increment : int; (*

Сколько добавить к основному куску памяти при его увеличении. Если это число меньше или равно 1000, это процент от текущего размера куска памяти (т.е. установка его на 100 удвоит размер куска памяти при каждом увеличении). Если это число больше 1000, это фиксированное количество слов, которое будет добавлено к куску памяти. По умолчанию: 15.

*)
space_overhead : int; (*

Скорость основного сбора мусора вычисляется по этому параметру. Это память, которая будет «потеряна», потому что сборщик мусора не сразу собирает недостижимые блоки. Она выражается в процентах от памяти, используемой для активных данных. Сборщик мусора будет работать больше (использовать больше времени процессора и собирать блоки более активно), если space_overhead меньше. По умолчанию: 120.

*)
verbose : int; (*

Это значение контролирует сообщения GC в стандартный вывод ошибок. Оно является суммой некоторых из следующих флагов для вывода сообщений об соответствующих событиях:

  • 0x001 Начало и конец цикла основного сбора мусора.
  • 0x002 Сбор мусора меньшего масштаба и срез основного сбора мусора.
  • 0x004 Увеличение и уменьшение куска памяти.
  • 0x008 Изменение размеров стеков и таблиц менеджера памяти.
  • 0x010 Уплотнение куска памяти.
  • 0x020 Изменение параметров GC.
  • 0x040 Вычисление размера среза основного сбора мусора.
  • 0x080 Вызов функций финализации.
  • 0x100 Поиск исполняемого байткода и общих библиотек при запуске.
  • 0x200 Вычисление условия срабатывания уплотнения.
  • 0x400 Вывод статистики GC при завершении программы. По умолчанию: 0.
*)
max_overhead : int; (*

Уплотнение куска памяти срабатывает, когда предполагаемое количество «потерянной» памяти превышает max_overhead процентов от количества активных данных. Если max_overhead установлено в 0, уплотнение куска памяти срабатывает в конце каждого цикла основного сбора мусора (эта настройка предназначена только для целей тестирования). Если max_overhead >= 1000000, уплотнение никогда не срабатывает. Если уплотнение постоянно отключено, рекомендуется установить allocation_policy в 2. По умолчанию: 500.

*)
stack_limit : int; (*

Максимальный размер стеков волокон (в словах). По умолчанию: 1024k.

*)
allocation_policy : int; (*

Политика, используемая для выделения памяти в основном куске. Возможные значения: 0, 1 и 2.

  • 0 — политика «следующее подходящее место», которая обычно быстрая, но может привести к фрагментации, увеличивая потребление памяти.
  • 1 — политика «первое подходящее место», которая избегает фрагментации, но имеет граничные случаи (в определенных реалистичных рабочих нагрузках), где она заметно медленнее.
  • 2 — политика «лучшее подходящее место», которая быстрая и избегает фрагментации. В наших экспериментах она быстрее и использует меньше памяти, чем обе предыдущие политики («следующее подходящее место» и «первое подходящее место»). (с OCaml 4.10)

По умолчанию используется политика «лучшее подходящее место».

В одном примере, известном как плохой для политик «следующее подходящее место» и «первое подходящее место», «следующее подходящее место» заняло 28 с, используя 855 Мбайт памяти, «первое подходящее место» — 47 с, используя 566 Мбайт памяти, а «лучшее подходящее место» — 27 с, используя 545 Мбайт памяти.

Примечание: Если вы измените политику на «следующее подходящее место», вам может потребоваться уменьшить значение space_overhead, например, используя 80, вместо значения по умолчанию 120, которое настроен для политики «лучшее подходящее место». В противном случае вашей программе потребуется больше памяти.

Примечание: изменение политики выделения во время выполнения принудительно вызывает уплотнение куска памяти, что является длительной операцией, если кусок памяти небольшой (например, в начале программы).

По умолчанию: 2.

  • Since 3.11.0
*)
window_size : int; (*

Размер окна, используемого основным GC для сглаживания колебаний его рабочей нагрузки. Это целое число от 1 до 50. По умолчанию: 1.

  • Since 4.03.0
*)
custom_major_ratio : int; (*

Целевое соотношение плавающего мусора к размеру основного куска памяти для внекусковой памяти, удерживаемой пользовательскими значениями, расположенными в основном куске. Скорость GC корректируется для попытки использовать столько памяти для мертвых значений, которые еще не собраны. Выражается в процентах от размера основного куска. Значение по умолчанию поддерживает размер плавающего внекускового мусора примерно таким же, как размер накладных расходов в куске. Примечание: это относится только к значениям, выделенным с caml_alloc_custom_mem (например, bigarrays). По умолчанию: 44.

  • Since 4.08.0
*)
custom_minor_ratio : int; (*

Ограничение плавающего мусора для внекусковой памяти, удерживаемой пользовательскими значениями в меньшем куске. Сбор мусора меньшего масштаба запускается, когда столько памяти удерживается пользовательскими значениями, расположенными в меньшем куске. Выражается в процентах от размера меньшего куска. Примечание: это относится только к значениям, выделенным с caml_alloc_custom_mem (например, bigarrays). По умолчанию: 100.

  • Since 4.08.0
*)
custom_minor_max_size : int; (*

Максимальное количество внекусковой памяти для каждого пользовательского значения, выделенного в меньшем куске. Когда пользовательское значение выделяется в меньшем куске и содержит больше байтов, чем это значение, только это значение учитывается против custom_minor_ratio, а остальное напрямую учитывается против custom_major_ratio. Примечание: это относится только к значениям, выделенным с caml_alloc_custom_mem (например, bigarrays). По умолчанию: 8192 байта.

  • Since 4.08.0
*)
}

Параметры GC задаются как запись control. Обратите внимание, что эти параметры также могут быть инициализированы с помощью переменной среды OCAMLRUNPARAM. См. документацию по ocamlrun.

val stat : unit -> stat

Возвращает текущие значения счетчиков управления памятью в записи stat, которая представляет общую статистику памяти программы. Эта функция вызывает полный основной сбор мусора.

val quick_stat : unit -> stat

То же, что и stat, за исключением того, что live_words, live_blocks, free_words, free_blocks, largest_free, и fragments установлены в 0. Из-за буферов по областям, оно может представлять только состояние общего использования памяти программы с момента последнего сбора мусора меньшего масштаба. Эта функция намного быстрее, чем stat, поскольку ей не нужно вызывать полный основной сбор мусора.

val counters : unit -> float * float * float

Возвращает (minor_words, promoted_words, major_words) для текущей области или потенциально для предыдущих областей. Эта функция так же быстра, как quick_stat.

val minor_words : unit -> float

Количество слов, выделенных в меньшем куске памяти данной областью или потенциально предыдущими областями. Это число точное в программах на байткоде, но только приблизительное в программах, скомпилированных в машинный код.

В программах на машинном коде эта функция не выделяет память.

  • Since 4.04
val get : unit -> control

Возвращает текущие значения параметров сборщика мусора в записи control.

  • Предупреждение unsynchronized_access. Параметры сборщика мусора — это изменчивое глобальное состояние.
val set : control -> unit

set r изменяет параметры сборщика мусора в соответствии с записями control r. Обычное использование: Gc.set { (Gc.get()) with Gc.verbose = 0x00d }

  • Предупреждение unsynchronized_access. Параметры сборщика мусора — это изменчивое глобальное состояние.
val minor : unit -> unit

Вызывает минорную коллекцию.

val major_slice : int -> int

major_slice n Выполняет минорную коллекцию и срез мажорной коллекции. n — размер среза: сборщик мусора выполнит достаточно работы, чтобы освободить (в среднем) n слов памяти. Если n = 0, сборщик мусора попытается выполнить достаточно работы, чтобы гарантировать, что следующему автоматическому срезу не потребуется работы. Эта функция возвращает неопределенное целое число (в настоящее время: 0).

val major : unit -> unit

Выполняет минорную коллекцию и завершает текущий цикл мажорной коллекции.

val full_major : unit -> unit

Выполняет минорную коллекцию, завершает текущий цикл мажорной коллекции и выполняет новый полный цикл. Это позволит собрать все в настоящее время недостижимые блоки.

val compact : unit -> unit

Выполняет полную мажорную коллекцию и компактирует кучу. Обратите внимание, что компактирование кучи — длительная операция.

val print_stat : out_channel -> unit

Выводит текущие значения счётчиков управления памятью (в удобочитаемой форме) всей программы в канал аргумента.

val allocated_bytes : unit -> float

Возвращает количество байтов, выделенных этим домен и потенциально предыдущим домен. Оно возвращается как float, чтобы избежать проблем с переполнением int на 32-битных машинах.

val get_minor_free : unit -> int

Возвращает текущий размер свободного места в минорной куче этого домена.

  • С 4.03.0
val finalise : ('a -> unit) -> 'a -> unit

finalise f v регистрирует f как функцию финализации для v. v должен быть выделен в куче. f будет вызван с v в качестве аргумента в какой-то момент между первым временем, когда v становится недостижимым (включая через слабые указатели), и временем, когда v собирается сборщиком мусора. Для одного значения могут быть зарегистрированы несколько функций, или даже несколько экземпляров одной и той же функции. Каждый экземпляр будет вызван один раз (или ни разу, если программа завершится до того, как v станет недостижимым).

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

При наличии нескольких потоков OCaml следует предполагать, что любая конкретная функция финализации может быть выполнена в любом потоке.

Всё, что достижимо из замыкания функций финализации, считается достижимым, поэтому следующий код не будет работать как ожидается:

  •  let v = ... in Gc.finalise (fun _ -> ...v...) v 

Вместо этого следует убедиться, что v не находится в замыкании функции финализации, написав:

  •  let f = fun x -> ...  let v = ... in Gc.finalise f v 

Функция f может использовать все возможности OCaml, включая присваивания, которые делают значение снова достижимым. Она также может циклически выполняться вечно (в этом случае другие функции финализации не будут вызваны во время выполнения f, если она не вызовет finalise_release). Она может вызвать finalise на v или других значениях, чтобы зарегистрировать другие функции или даже себя. Она может вызвать исключение; в этом случае исключение прервёт то, что программа делала, когда функция была вызвана.

finalise вызовет Invalid_argument, если v не гарантирует выделение в куче. Некоторые примеры значений, которые не выделены в куче, — это целые числа, константные конструкторы, булевы значения, пустой массив, пустой список, единичное значение. Точный список того, что выделено в куче или нет, зависит от реализации. Некоторые константные значения могут быть выделены в куче, но никогда не освобождаться в течение жизни программы, например, список константных целых чисел; это также зависит от реализации. Обратите внимание, что значения типов float иногда выделяются в куче, а иногда и нет, поэтому финализация их небезопасна, и finalise также вызовет Invalid_argument для них. Значения типа 'a Lazy.t (для любого 'a) в этом отношении похожи на float, за исключением того, что компилятор иногда оптимизирует их таким образом, что finalise не обнаруживает их. В этом случае он не вызовет Invalid_argument, но вы всё равно должны избегать вызова finalise для ленивых значений.

Результаты вызова String.make, Bytes.make, Bytes.create, Array.make и ref гарантированно выделяются в куче и не являются константными, за исключением случаев, когда аргумент длины равен 0.

val finalise_last : (unit -> unit) -> 'a -> unit

то же самое, что и Gc.finalise, за исключением того, что значение не передаётся в качестве аргумента. Таким образом, вы не можете использовать заданное значение для вычисления функции финализации. Преимущество состоит в том, что функция вызывается после того, как значение становится недостижимым в последний раз, а не в первый раз. Итак, в отличие от Gc.finalise, значение больше никогда не будет достижимым или используемым. В частности, все слабые указатели и эфемеры, содержащие это значение в качестве ключа или данных, сбрасываются перед запуском функции финализации. Более того, функции финализации, присоединённые с помощью Gc.finalise, всегда вызываются перед функциями финализации, присоединёнными с помощью Gc.finalise_last.

  • С 4.04
val finalise_release : unit -> unit

Функция финализации может вызвать finalise_release , чтобы сообщить сборщику мусора, что он может запустить следующую функцию финализации, не дожидаясь возврата текущей.

type alarm 

Сигнал — это данные, которые вызывают пользовательскую функцию в конце каждого цикла мажорного сборки мусора. Для создания и удаления сигналов предоставлены следующие функции.

val create_alarm : (unit -> unit) -> alarm

create_alarm f обеспечит вызов f в конце каждого цикла мажорной сборки мусора, начиная с текущего или следующего цикла. Возвращается значение типа alarm, которое можно использовать для вызова delete_alarm.

val delete_alarm : alarm -> unit

delete_alarm a прекратит вызовы функции, связанной с a. Повторный вызов delete_alarm a не окажет никакого эффекта.

val eventlog_pause : unit -> unit
Устарело. Используйте Runtime_events.pause вместо этого.
val eventlog_resume : unit -> unit
Устарело. Используйте Runtime_events.resume вместо этого.
module Memprof: sig .. end

Memprof — это механизм выборки для выделенных слов памяти.

© 1995-2022 INRIA.
https://v2.ocaml.org/releases/5.0/htmlman/libref/Gc.html

Spec-Zone.ru

Настройки Оффлайн Что нового Помощь О нас
Spec-Zone .ru
спецификации, руководства, описания, API