Spec-Zone.ru › OCaml 4.14

Модуль 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 не вернёт значения, у которых есть finalizer из 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 = {
mutable minor_heap_size : int; (*

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

*)
mutable major_heap_increment : int; (*

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

*)
mutable space_overhead : int; (*

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

*)
mutable verbose : int; (*

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

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

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

*)
mutable stack_limit : int; (*

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

*)
mutable 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; (*

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

  • Since 4.03.0
*)
custom_major_ratio : int; (*

Целевая доля плавающего мусора к размеру основной кучи для памяти вне кучи, удерживаемой пользовательскими значениями, расположенными в основной куче. Скорость сборщика мусора настраивается для попытки использования этого количества памяти для «мёртвых» значений, которые ещё не собраны. Выражается как процент от размера основной кучи. Значение по умолчанию поддерживает размер плавающего мусора вне кучи примерно такой же, как и накладные расходы внутри кучи. Примечание: это относится только к значениям, выделенным с помощью 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
*)
}

Параметры сборщика мусора задаются в виде записи 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.

val set : control -> unit

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

val minor : unit -> unit

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

val major_slice : int -> int

major_slice n Выполнить минорную коллекцию и часть основной коллекции. n — размер части: GC выполнит достаточно работы, чтобы освободить (в среднем) n слова памяти. Если n = 0, GC попытается выполнить достаточно работы, чтобы гарантировать, что следующая автоматическая часть не потребует работы. Эта функция возвращает неопределённое целое число (в настоящее время: 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

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

  • Since 4.03.0
val get_bucket : int -> int

get_bucket n возвращает текущий размер n-го будущего ведра системы сглаживания GC. Единица — одна миллионная часть полного GC.

  • Since 4.03.0
  • Raises Invalid_argument если n отрицательно, возвращает 0, если n больше окна сглаживания.
val get_credit : unit -> int

get_credit () возвращает текущий размер счётчика «работа, выполненная заранее» системы сглаживания GC. Единица — одна миллионная часть полного GC.

  • Since 4.03.0
val huge_fallback_count : unit -> int

Возвращает количество попыток отображения огромных страниц, после которых пришлось вернуться к маленьким страницам. Всегда 0, если OCAMLRUNPARAM содержит H=1.

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

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

GC вызовет функции завершения в порядке освобождения. Когда несколько значений становятся недоступными одновременно (т. е. во время одного цикла GC), функции завершения будут вызваны в обратном порядке соответствующих вызовов 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 иногда выделяются, а иногда нет, поэтому завершать их работу небезопасно, и Invalid_argument также вызовет 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.

  • Since 4.04
val finalise_release : unit -> unit

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

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

eventlog_pause () приостановит сбор трасс в среде выполнения. Трассы собираются, если программа связана со средой выполнения с инструментарием и запущена с переменной среды OCAML_EVENTLOG_ENABLED. События записываются на диск после приостановки, и новые события не будут регистрироваться до тех пор, пока не будет вызвано eventlog_resume.

val eventlog_resume : unit -> unit

eventlog_resume () возобновит сбор трасс в среде выполнения. Трассы собираются, если программа связана со средой выполнения с инструментарием и запущена с переменной среды OCAML_EVENTLOG_ENABLED. Этот вызов можно использовать после вызова eventlog_pause или если программа была запущена с OCAML_EVENTLOG_ENABLED=p. (что приостанавливает сбор трасс перед первым событием.)

module Memprof: sig .. end

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

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

Spec-Zone.ru

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