Make IDs 32bits

[vinistock]

Step towards #141

When thinking about using u32 IDs, I was getting really caught up by the fact that Rust's HashMap implementation still requires storing a u64 for the key digests. Of course that consumes more memory and ideally we can have a custom HashMap implementation that uses half the amount of bits.

However, we actually use IDs quite extensively outside of just HashMap keys. For example, many definitions store StringId, names store multiple NameIds and ancestors is a list of DeclarationId. We can actually have very substantial memory savings right now even without the 32 bit HashMap.

Implementation

This PR reduces the size of our IDs to u32 from i64. I recommend reviewing per commit:

1. Reduce the ID size to u32

2. Allow DefinitionId and ReferenceId to be tagged with their kind. This helps us reduce the changes of collision by encoding the kind in the lower bits of the ID. Essentially, we have 28 bits for the digest + 4 for the kind. Definitions and references are the things we have the most in Core and the only ones I got conflicts for running the release mode, so I think this is enough for the time being.

   As an added benefit, this allows to check the kind of definitions and references without having to retrieve them from the graph. That information is directly encoded in the ID, we can just invoke kind. Note that the kind addition conflicts with Provide resolution diagnostics (inline) #502, we can let that PR go first.

3. Adjust the C side to use u32

Impact

Despite still using 64 bit HashMaps, this PR still reduces our memory used from ~3810 MB to
~2880 MB (25% reduction).

I believe we can further reduce this with a custom HashMap implementation that stores u32 internally.

Why now?

I believe this is the right time to do this for the following reason: we're starting adoption of Rubydex in our tools. It will be easier for us to verify that we can indeed get away with u32 and lower memory usage and then increase to u64 if necessary than the other way around.

Also, we're almost getting to 4GB and a reduction is definitely welcome.

[vinistock]

• Make IDs 32bits #542 👈 (View in Graphite)
• Reduce ref count sizes #541
• main

This stack of pull requests is managed by Graphite. Learn more about stacking.

[Morriar]

Should we also tag declarations?

[vinistock]

I haven't figure out a good way to do it. Consider our Ruby API:

graph["Foo"]

The Ruby API has no way of knowing what Foo is before looking it up, so we wouldn't be able to construct the right DeclarationId to search.

For now, I think it's okay because we have a lot fewer declarations than definitions.

[Morriar]

You should be able to fit this in 4 bits?

[vinistock]

Is there a way to do this? u8 is the smallest integer storage we can use no?

[Morriar]

4 bits should be enough?