Add PerfTools::DumpHeap

[HertzDevil]

Resolves #5.

This is a very primitive binary dump and, as mentioned in the issue, requires compiler support to emit the appropriate type info at build time so that other tools can comprehend those dumps (CRYSTAL_DUMP_TYPE_ID=1 will let you visually identify some allocations in a hex editor at the moment).

Apart from these custom formats, maybe we could try to produce industry or community standard memory dumps in the future...?

[ysbaddaden]

That's pretty nice! I've been pondering about this for a while.

I see just a couple issues:

1. should stop the world while we dump the heap so it's MT compatible (that one's easy).

2. We can't allocate anything, but stdlib will happily allocate anywhere... Maybe we could introduce Crystal::System.read(fd, slice) and .write(fd, slice) methods that would directly read from and write to a system fd or handle?

[ysbaddaden]

Suggestion: maybe call it #compact as the description states? It would be more aligned with the #full version.

[HertzDevil]

2. We can't allocate anything, but stdlib will happily allocate anywhere

Do you mean that GC.lock_write + sync = true + stop-the-world are still insufficient because there could still be fiber switches while dumping?

[ysbaddaden]

Thank you, it looks great to me for the initial step 🙇

[HertzDevil]

It is possible to eliminate GC allocations from the IO itself like this: (Win32)

class RawIO < IO
  def initialize(@handle : LibC::HANDLE)
  end

  def read(slice : Bytes)
    LibC.WriteFile(@handle, slice, slice.size, out read_count, nil)
    read_count.to_i32
  end

  def write(slice : Bytes) : Nil
    LibC.WriteFile(@handle, slice, slice.size, nil, nil)
  end
end

macro open_raw_file(path, mode = "r", &block)
  {% write = mode == "w" ? true : mode == "r" ? false : mode.raise "Unknown file mode: #{mode.id}" %}

  # if `path.to_utf16` uses a fixed-size stack buffer then
  # this macro could even be turned into a regular method
  %handle = ::LibC.CreateFileW(
    {{ path.to_utf16 }},
    {% if write %} ::LibC::FILE_GENERIC_WRITE {% else %} ::LibC::FILE_GENERIC_READ {% end %},
    ::LibC::DEFAULT_SHARE_MODE,
    nil,
    {% if write %} ::LibC::CREATE_ALWAYS {% else %} ::LibC::OPEN_EXISTING {% end %},
    ::LibC::FILE_FLAG_BACKUP_SEMANTICS,
    nil,
  )

  if %handle == ::LibC::INVALID_HANDLE_VALUE
    ::raise(::RuntimeError.new("CreateFileW"))
  end

  begin
    %raw_io_buf = uninitialized ::ReferenceStorage(::RawIO)
    {{ block.args[0] }} = ::RawIO.unsafe_construct(pointerof(%raw_io_buf), %handle)
    {{ block.body }}
  ensure
    ::LibC.CloseHandle(%handle)
  end
end

open_raw_file("heap.bin", "w") do |f|
  PerfTools::DumpHeap.full(f)
end