Teo Camarasu authored 1 year ago and Teo Camarasu committed 4 days ago

Block groups on the haskell heap normally only consist of one block,
but can be longer, eg, for large/pinned objects, compact regions, or for
segments on the nonmoving heap.

We have to take care in our implementation of the block cache and take
this into account when looking up closures.

See: Note [Block groups and the block cache].

Resolves #7

This fixes #32

This commit allows you the ghc-debug-brick interface to incrementally
update whilst a query is being run.

* Decouple the state update from the parallel traversal code
* Implement async parallel and sequential traversals
* Implement retainer traversal in terms of a parallel traversal.

The `closure_desc` of `InfoProv_` was changed from an `char *` to an
`uint32_t`. This change was mostly done to fix issue:
ghc#24504

We adapt the stub to these changes by essentially converting the number
stored in `closure_desc` to its string representation, as most tools
expect this format.
For example, the number `10` is turned into the string `"10"`.

This has long been unused and introduces additional dependencies into
the install plan.

Adds colouring to the `CensusStats` for improved readability. It is now
easier to find the appropriate values across lines.

Omit package and module name from the item list view. The package name
can easily be over 70 characters long, and are thus unreadable on most
monitors any way.
The header panel still shows all the information when hovering over the
relevant list item, and the on-disk results are not affected.

Additionally, homogeneous Arrays do no longer show all entires but show
how many entries of the same closure type they contain.
This reduces memory usage, but also the on-disk size of the two-level
census results.

To make this possible without parsing in various locations, we store structured
information about each Closure Type Census while traversing the heap.
In particular, we store the original `ConstrDesc` and put it into a
single `Text`, where individual entries are split by ";".
This avoids most overhead introduced by the additional data structures.

At long last, we also switch to `Data.Text.IO` for writing the census
results to disk. This seems to remove a memory spike when immediately
writing the results to disk after a census.

Previously exceptions on worker threads were swallowed and lead to a
deadlock. Now an exception will kill the entire process.

We also need to find all the RequestBlock requests and add those into
the block cache, as well as the results of RequestAllBlocks.