sig
  type stat =
    Stdlib.Gc.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;
    live_blocks : int;
    free_words : int;
    free_blocks : int;
    largest_free : int;
    fragments : int;
    compactions : int;
    top_heap_words : int;
    stack_size : int;
    forced_major_collections : int;
  }
  type control =
    Stdlib.Gc.control = {
    mutable minor_heap_size : int;
    mutable major_heap_increment : int;
    mutable space_overhead : int;
    mutable verbose : int;
    mutable max_overhead : int;
    mutable stack_limit : int;
    mutable allocation_policy : int;
    window_size : int;
    custom_major_ratio : int;
    custom_minor_ratio : int;
    custom_minor_max_size : int;
  }
  external stat : unit -> BatGc.stat = "caml_gc_stat"
  external quick_stat : unit -> BatGc.stat = "caml_gc_quick_stat"
  external counters : unit -> float * float * float = "caml_gc_counters"
  external minor_words : unit -> (float [@unboxed]) = "caml_gc_minor_words"
    "caml_gc_minor_words_unboxed"
  external get : unit -> BatGc.control = "caml_gc_get"
  external set : BatGc.control -> unit = "caml_gc_set"
  external minor : unit -> unit = "caml_gc_minor"
  external major_slice : int -> int = "caml_gc_major_slice"
  external major : unit -> unit = "caml_gc_major"
  external full_major : unit -> unit = "caml_gc_full_major"
  external compact : unit -> unit = "caml_gc_compaction"
  val print_stat : 'a BatInnerIO.output -> unit
  val allocated_bytes : unit -> float
  external get_minor_free : unit -> int = "caml_get_minor_free"
  external get_bucket : int -> int = "caml_get_major_bucket" [@@noalloc]
  external get_credit : unit -> int = "caml_get_major_credit" [@@noalloc]
  external huge_fallback_count : unit -> int = "caml_gc_huge_fallback_count"
  val finalise : ('a -> unit) -> 'a -> unit
  val finalise_last : (unit -> unit) -> 'a -> unit
  val finalise_release : unit -> unit
  type alarm = Stdlib.Gc.alarm
  val create_alarm : (unit -> unit) -> BatGc.alarm
  val delete_alarm : BatGc.alarm -> unit
  external eventlog_pause : unit -> unit = "caml_eventlog_pause"
  external eventlog_resume : unit -> unit = "caml_eventlog_resume"
  module Memprof :
    sig
      type allocation_source =
        Stdlib.Gc.Memprof.allocation_source =
          Normal
        | Marshal
        | Custom
      type allocation =
        Stdlib.Gc.Memprof.allocation = private {
        n_samples : int;
        size : int;
        source : BatGc.Memprof.allocation_source;
        callstack : Stdlib.Printexc.raw_backtrace;
      }
      type ('minor, 'major) tracker =
        ('minor, 'major) Stdlib.Gc.Memprof.tracker = {
        alloc_minor : BatGc.Memprof.allocation -> 'minor option;
        alloc_major : BatGc.Memprof.allocation -> 'major option;
        promote : 'minor -> 'major option;
        dealloc_minor : 'minor -> unit;
        dealloc_major : 'major -> unit;
      }
      val null_tracker : ('minor, 'major) BatGc.Memprof.tracker
      val start :
        sampling_rate:float ->
        ?callstack_size:int -> ('minor, 'major) BatGc.Memprof.tracker -> unit
      val stop : unit -> unit
    end
end