Summary

AsyncDependenciesBlock is of the size of 208 bytes. It was pre-allocated for the capacity of 256:

size_of::<AsyncDependenciesBlock>() = 208

Taking a project with 10000 modules. It will at least allocate (and destroy) the memory of 256 * 208 * 10000 bytes (507Mbs), causing a memory increment and decrement back and forth.

Since the layout AsyncDependenciesBlock is quite compat, two approaches remain:

• Change Vec<AsyncDependenciesBlock> to Vec<Box<AsyncDependenciesBlock>>
• Change initial capacity of the Vec to a smaller value

The first solution is to reduce the memory usage from 256 * 208 to 256 * 24, giving us a significant memory reduce, however with some potential overhead for sending the value to the heap.
With the second capacity change from 256 to 64.

I also changed the initial capacity of other vecs, although it does not(and should not) have much memory cost difference.

Performance for big projects

The performance difference between these two changes of our internal project of 38134 modules remain unnoticeable. It's around 30 seconds for each build on my computer (Apple M2 Max, 64 GB).

Memory cost

The memory cost of this is a constant value for each module. With the difference number of modules, it results in different amount of allocations created and destroyed. Taking 10000 modules case as an example, we can notice the difference of memory being created and destroyed during each build:

Before:

After:

It's 12.5% improvement of the total memory being allocated.

Clippy complaints of Vec<Box<T>> where T: Sized

Clippy is complaining that T of Vec<T> was already allocated on the heap. Since it's a huge struct with that much of pre-allocation, we can workaround this as it was said in the detail page: rust-lang/rust-clippy#3530

Checklist

• Tests updated (or not required).
• Documentation updated (or not required).