Ideas on how to improve compile-time

[NobodyXu]

Summary 💡

De-monomorphisation

Function like gix::clone::PrepareFetch::new can be trivally de-monomorphised by extracting an inner function.

Sebastian Thiel (@Byron) It's possible we can do this without sacrificing code readability by creating our own variant of momo.

For gix::clone::PrepareFetch::fetch_then_checkout it would be harder since Progress is not an dyn-safe trait.

I would like to add another provided method to Progress:

/// An opaque type so that `gix` can internally change its implementation details,
/// e.g. use an `Arc` instead of `Box`, or even inlining the progress.
pub struct DynProgress;

impl DynProgress {
    pub fn new<P: Progress>(p: P) -> Self;
}

impl Progress for DynProgress {
    type SubProgress = Self;

    // ...
}

trait Progress {
    // ...

    // Provided method
    fn into_dyn_progressive(self) -> DynProgress;
}

Features

For starters, I think we can put gix_negotiate, gix_ignore and gix_utils behind new feature flags.

Then we can put ability to fetch and update new repository into its own features since many crates might just want to discover local repository, e.g. vergen.

Motivation 🔦

As shown in cargo-bins/cargo-binstall#1304 (comment) , compilation of gix (not its dependencies) on GHA MacOS runner took more than 60s, which is a bit too long.

simple-git, which only uses a few gix interface, also takes 34s just to compile.

I believe this is caused by two factors:

• too much monomorphization
• too many unused code and dependencies pulled in

Progress

• Use dyn where possible, including dyn based progress traits #1008
• gix feature toggles #1010
• gix-error crate as replacement for thiserror

[Byron]

Thanks for bringing up ideas for a way forward to reducing compile times, it's very much appreciated and I think it's good to start this sooner than later.

Monomorphization

First of all, I agree that in most cases, monomorphization can be considered a convenience rather than a necessity (i.e. performance). Thus I believe that unless a function or closure isn't going to be called millions of times per second, there is no need to monomorphize it. Most methods and functions provided here fulfil this criterium. This affects most places where callbacks and the Progress trait is used.

about prodash and Progress

Thus I am very open to offering a &dyn compatible progress trait and all necessary refactorings to prodash can be done to accomplish this. I may say though that in the presence of threads all this gets a little more complicated and we may want to change set setters of Progress to use &self instead of &mut self, as most implementations internally are thread-safe anyway. prodash was originally designed so that each handle to a Progress implementation is handed to a thread, so the are not Clone themselves, so there now is a counter() method to workaround that. Maybe that can be cleaned up in the progress as well. Performance for Progress is critical, of course, but with the proposed optional dyn support we can have the best of both worlds.

Momo or not

I think it's worth making the process of monomorphization simpler and using a custom version of momo may help with that. I also hope that by using a source-only way of building it doesn't add too much compile time - for obvious reasons I don't want to have any kind of non-auditable blobs in the dependency chain until auditable blobs are supported by cargo natively. If there is doubt about its feasibility or difficulty, it's definitely fine to write the 'landing pads' by hand for the heavy-hitting functions.

About feature toggles

I'd love to start thinking about feature toggles in higher-level concepts, or components if you will. Like attributes or excludes or pathspecs. Each of these would be a feature toggle. This would also mean that features like fetch then require a certain set of components to work, and such methods might not be available unless the toggles are satisfied.
Given how painful feature toggles have been for me, I will be much more in touch with this part of the optimizations and would definitely be providing a set of components along with their dependencies, down to the plumbing crates that this affects.

Vergen

Yes, vergen will benefit from 'componentalization', even though one might also consider going all plumbing there. It won't get much better than that then, even though indeed I would hope that gix can be made so that most people still won't need to use plumbing just to get minimal compile times.

Testing of feature toggles

I think cargo-all-features would have to be used to assure everything works as intended - this will add CI time but we can probably just run it on its own machine to run in parallel to all the other ones. The budget of ~30min should be enough for that.

Let me thank you again for taking the lead in this 🙏 - I will support you as good as I can.

[NobodyXu]

Thus I am very open to offering a &dyn compatible progress trait and all necessary refactorings to prodash can be done to accomplish this.

Thanks, I've opened GitoxideLabs/prodash#22

I may say though that in the presence of threads all this gets a little more complicated and we may want to change set setters of Progress to use &self instead of &mut self, as most implementations internally are thread-safe anyway.

That can also be done easily,

prodash was originally designed so that each handle to a Progress implementation is handed to a thread, so the are not Clone themselves, so there now is a counter() method to workaround that. Maybe that can be cleaned up in the progress as well. Performance for Progress is critical, of course, but with the proposed optional dyn support we can have the best of both worlds.

Once Progress is changed to use immutable reference, perhaps we can change this to return AtomicUsize instead?

For sharing across threads, I think std::thread::Builder::spawn_scoped or rayon::in_place_scope could be used to avoid that Arc.

[Byron]

Once Progress is changed to use immutable reference, perhaps we can change this to return AtomicUsize instead?

It already does it, but it's using shared ownership. Doing so actually makes it easier to use as those who don't need ownership over the AtomicUsize which lies underneath can always borrow it to scoped threads if they wish. Changing this is probably more like a rewrite of what prodash represents.

---

I couldn't resit but to get an overview for myself of what's possible here, and I think it's a lot. For one, I already started the compartmentalization in gix by adding new but less used capabilities behind a feature toggle. This was easy as they were nicely separated. Others are more intertwined, but I think this map will help to plan where to make the cuts.

                                                                                                            ╔════════════════════╗
                                                 ┌─────────────────────────────────────────────────────────▶║     Submodules     ║
                                                 │                                                          ╚════════════════════╝
                                                 │                                                                     ▲                                                                           ╔════════════════════╗      ╔════════════════════╗
                                                 │                                                                     │                                                                           ║   Fetch Changes    ║◀──┬─▶║    Push Changes    ║
                                                 │                                                                     │                                                                           ╚════════════════════╝   │  ╚════════════════════╝
                                                 │                                                                     │                                                                                      ▲             │             ▲
                                                 │   ╔═══════════════════╗                      ╔══════════════╗       │                                                                                      │             │             │
                                                 │   ║gix-worktree-state ║                      ║  gix-status  ║       │                                                                                      │             │             │
                                                 │   ╚═══════════════════╝                      ╚══════════════╝       │                                                                                      │             │             │
                                                 │             ▲                                        ▲              │                          ┌────────────────────┐         ╔════════════════════╗       │             │             │
                                                 │             │                                        │              │                          │     imara-diff     │────────▶║     Blob-Diff      ║       │             │             │
                                                 │             │                                        │              │                          └────────────────────┘         ╚════════════════════╝       │             └─────────────┼────────────────────────┐
                                                 │             │                                        │              │                                                                    ▲                 │                           │                        │
                                                 │             │                                        │              │                                                                    │                 └──────────────┬────────────┘                        │
                                                 │             └─────────────────────┬──────────────────┘              └───────────────────────────────────────────────────────────────┐    │                                │                                     │
                                                 │                                   │                                                                                                 │    │                                │                                     │
                                                 │                                   │                                                ╔════════════════════╗  ╔══════════════════╗     │    │    ╔═══════════════╗           │                                     │
                                                 │                                   │                                                ║      Describe      ║  ║ Traverse Commits ║     │    │    ║   Tree-Diff   ║           │                                     │
                                                 │                                   │                                                ╚════════════════════╝  ╚══════════════════╝     │    │    ╚═══════════════╝           │                                     │
                                                 │                                   │                                                           ▲                      ▲              │    │            ▲                   │                                     │
    ╔════════════════════╗              ╔════════════════╗                 ╔═══════════════════╗                                                 │                      │              │    │            │                   │                                     │
    ║    gix-archive     ║              ║ gix-submodule  ║        ┌───────▶║   gix-worktree    ║◀──────────┐                                     │                      │              │    │            │                   │                                     │
    ╚════════════════════╝              ╚════════════════╝        │        ╚═══════════════════╝           │                                     │                      │              │    │            │                   │                                     │
               ▲                                 ▲                │                  ▲                     │                                     ├──────────────────────┼──────────────┼────┴────────────┤                   │                                     │
               │                                 │                │                  │                     │                                     │                      │              │                 │                   │                                     │
               │                                 │                │                  │                     │                                     │                      │              │                 │                   │                                     │
               │                                 │                │                  │                     │                                     │                      │              │                 │                   │                                     │
               │                                 │                │                  │                     │                                     │                      │              │                 │                   │                                     │
               │                                 │                │                  │                     │                                     │                      │   ╔════════════════════╗       │         ╔═══════════════════╗                           │
               │                                 │                │                  │                     │                                     │ ┌────────────────────┼──▶║     Repository     ║───────┼────────▶║      Remote       ║                           │
               │                                 │                │                  │                     │                                     │ │                    │   ╚════════════════════╝       │         ╚═══════════════════╝                           │
 ╔═══════════════════════════╗          ╔════════════════╗        │                  │           ╔═══════════════════╗    ╔═══════════════════╗  │ │                    │              ▲                 │                   ▲                                     │
 ║    gix-worktree-stream    ║          ║  gix-pathspec  ║◀─┐     │         ┌────────┴──────┐    ║     gix-index     ║    ║   gix-revision    ║──┘ │                    │              │       ╔═══════════════════╗         │                                     │
 ╚═══════════════════════════╝          ╚════════════════╝  │     │         │               │    ╚═══════════════════╝    ╚═══════════════════╝    │                    └──────────────┼───────║   gix-traverse    ║         │                                     │
               ▲                                 ▲          │     │         │               │                                                      │                                   │       ╚═══════════════════╝         │                                     │
               │                                 │          │     │         │               │                                                      │                                   │                                     │                                     │
               │                                 │          │     │         │               │                                                      │           ┌───────────────────────┼───────────────────────┐             │                                     │
               │                                 │          │     │         │               │                                                      │           │                       │                       │             ├────────────┐                        │
               │                                 │          │     │         │               │                                                      │           │                       │                       │             │            │                        │
               │                                 │          │     │         │               │                                                      │           │                       │                       │             │            │                        │
               │                                 │          │     │         │               │                                                      │           │                       │                       │             │            │                        │
               │                                 │          │     │         │               │                                                      │           │                       │                       │             │            │                        │
               │                        ╔════════════════╗  │     │  ╔════════════╗  ╔════════════╗                                                │           │                       │                       │             │            │                        │
               └────────────────────────║ gix-attributes ║──┼─────┴─▶║ gix-filter ║  ║ gix-ignore ║                                                │ ╔═══════════════════╗      ╔════════════╗      ╔═════════════════════╗  │            │             ╔════════════════════╗
                                        ╚════════════════╝  │        ╚════════════╝  ╚════════════╝                                                │ ║  Object Storage   ║      ║ References ║      ║    Configuration    ║  │  ╔═══════════════════╗   ║    gix-protocol    ║
                                                 ▲          │                               ▲                                                      │ ║     (gix-odb)     ║      ║ (gix-ref)  ║      ║    (gix-config)     ║  │  ║  gix-credentials  ║   ╚════════════════════╝
                                                 │          │                               │                                                      │ ╚═══════════════════╝      ╚════════════╝      ╚═════════════════════╝  │  ╚═══════════════════╝              ▲
                                                 │          │                               │                                                      │           ▲                       ▲                                     │                                     │
                                                 │          │                               │                                                      │           │                       │                                     │                                     │
                                                 │          │                               │                                                      │           │                       │                                     │                                     │
                                                 │          │                               │                                                      │           │                       │                           ╔═══════════════════╗               ╔════════════════════╗
                                                 │          │                               │                                                      │           └───────────────────────┤                           ║    gix-refspec    ║               ║   gix-transport    ║
                                                 │          │                               │                                                      │                                   │                           ╚═══════════════════╝               ╚════════════════════╝
                                          ╔═════════════╗   │                               │          ╔═══════════════════╗                       │                                   │                                                                          ▲
                                          ║  gix-glob   ║───┴───────────────────────────────┘          ║    gix-mailmap    ║                       │                                   │                                                                          │
                                          ╚═════════════╝                                              ╚═══════════════════╝                       │                                   │                                                   ┌──────────────────────┼────────────────────────┐
                                                                                                                                                   │                                   │                                                   │                      │                        │
                                                                                                                                      ╔═════════════════════════╗      ╔══════════════════════════════╗                                    │                      │                        │
                                                                                                                                      ║  Repository Discovery   ║      ║      Temp and Lockfiles      ║                           ╔═════════════════╗ ╔═══════════════════════╗ ╔════════════════════╗
                                                                                                                                      ║     (gix-discover)      ║      ║  (gix-tempfile & gix-lock)   ║                           ║  Ssh Transport  ║ ║  Git Local Transport  ║ ║  Https-Transport   ║
                                                                                                                                      ╚═════════════════════════╝      ╚══════════════════════════════╝                           ╚═════════════════╝ ╚═══════════════════════╝ ╚════════════════════╝





┌───────────────────────────────────────────────────────────┐       ┌──────────────────────────────────────────────────────────┐        ┌──────────────────────────────────────────────────────────┐       ┌─────────────────────────────────────────────────────────────────────────┐
│                                                           │       │                                                          │        │                                                          │       │                                                                         │
│               _                         _   _             │       │            _                  _     _           _        │        │               _             _               _            │       │              _              __           _                              │
│              (_)                       | | | |            │       │           (_)                | |   (_)         | |       │        │              (_)           | |             | |           │       │             (_)            / _|         | |                             │
│          __ _ ___  ________ _ __   __ _| |_| |__          │       │       __ _ ___  ________ ___ | |__  _  ___  ___| |_      │        │          __ _ ___  ________| |__   __ _ ___| |__         │       │         __ _ ___  ________| |_ ___  __ _| |_ _   _ _ __ ___  ___        │
│         / _` | \ \/ /______| '_ \ / _` | __| '_ \         │       │      / _` | \ \/ /______/ _ \| '_ \| |/ _ \/ __| __|     │        │         / _` | \ \/ /______| '_ \ / _` / __| '_ \        │       │        / _` | \ \/ /______|  _/ _ \/ _` | __| | | | '__/ _ \/ __|       │
│        | (_| | |>  <       | |_) | (_| | |_| | | |        │       │     | (_| | |>  <      | (_) | |_) | |  __/ (__| |_      │        │        | (_| | |>  <       | | | | (_| \__ \ | | |       │       │       | (_| | |>  <       | ||  __/ (_| | |_| |_| | | |  __/\__ \       │
│         \__, |_/_/\_\      | .__/ \__,_|\__|_| |_|        │       │      \__, |_/_/\_\      \___/|_.__/| |\___|\___|\__|     │        │         \__, |_/_/\_\      |_| |_|\__,_|___/_| |_|       │       │        \__, |_/_/\_\      |_| \___|\__,_|\__|\__,_|_|  \___||___/       │
│          __/ |             | |                            │       │       __/ |                       _/ |                   │        │          __/ |                                           │       │         __/ |                                                           │
│         |___/              |_|                            │       │      |___/                       |__/                    │        │         |___/                                            │       │        |___/                                                            │
│                                                           │       │                                                          │        │                                                          │       │                                                                         │
└───────────────────────────────────────────────────────────┘       └──────────────────────────────────────────────────────────┘        └──────────────────────────────────────────────────────────┘       └─────────────────────────────────────────────────────────────────────────┘

                                                                                       ┌─────────────────────────────────────────────────────────────────────────────┐
                                                                                       │                                                                             │
                                                                                       │             _                              _        _   _ _                 │
                                                                                       │            (_)                            | |      | | | (_)                │
                                                                                       │        __ _ ___  ________ _ __   __ _  ___| | _____| |_| |_ _ __   ___      │
                                                                                       │       / _` | \ \/ /______| '_ \ / _` |/ __| |/ / _ \ __| | | '_ \ / _ \     │
                                                                                       │      | (_| | |>  <       | |_) | (_| | (__|   <  __/ |_| | | | | |  __/     │
                                                                                       │       \__, |_/_/\_\      | .__/ \__,_|\___|_|\_\___|\__|_|_|_| |_|\___|     │
                                                                                       │        __/ |             | |                                                │
                                                                                       │       |___/              |_|                                                │
                                                                                       │                                                                             │
                                                                                       └─────────────────────────────────────────────────────────────────────────────┘

It may look overwhelming, layout is hard 😅. These big crates at the bottom are basically foundation, they are always pulled in one way or another. Everything prefixed with gix- is a crate that also represents a component.

[Byron]

I thought about monomorphization a little more and after consulting with Josh Triplett (@joshtriplett) (thank you 🙏) came to a conclusion that I find exciting enough to share.

First of all, what are the costs of monomorphism? For the Rust compiler, at least the simple way they are used here, there is no significant overhead, so cargo check will run just as fast as it would with everything being polymorphic.
The real cost of generics occours when they are instantiated multiple times as this multiples the work LLVM has to do during cargo build.

With this in mind, and knowing that monomorphism is best for performance in this very performance-minded crate-ecosystem, and also good for convenience, I arrived at the following conclusions.

• plumbing crates, i.e. gix-*, should not polymorphize unless their own function calls are unnecessarily duplicated. If that's the case, probably detectable with cargo bloat, this should be fixed rather than polymorphising it.
  • If plumbing crate functions are prone to duplication due to calls from other plumbing crates, and performance is not a concern for the call, use use the generic function as a landing pad and forward it to a dyn trait version - let's call this momo from now on.
• the gix crate is assumed to primarily use generics for convenience and should absolutely avoid duplications of functions and methods. For that reason, momo should be use generously to retain the convenience of generics without causing (much) bloat. I assume that in most cases, performance won't matter and we can easily pay for the dyn overhead.

Since gix is the entry-point for most it seems to make sense to focus efforts there initially. I also hope that there will be a way to measure the effects of (probably unnecessary) function duplication at build time due to monomophism and use that as driver to fix these in the entire gix-* ecosystem.

I invite everyone involve to let me know their thoughts or point out mistakes or other flaws that ought to be improved. After all, I am threading on new grounds here. Thank you🙏.

[NobodyXu]

Sebastian Thiel (@Byron) Another advice for speeding up compilation of gitoxide itself:

I think it might be a good idea to support multi-call binary that can do both gix and ein and uses args[0] (symlink or hardlink name) to tell which one to call.

This would reduce:

• link time of gitoxide since it doesn't have to generate and link two binaries
• size of the executable generated

[Byron]

That's a good idea! It would check what is name is and then act differently depending on that.

I think from a setup and installation perspective, it's easiest to declare to binaries with the same path so cargo will create two full-size binaries (and install them) at the compile-time price of one. ein and gix are currently 9MB and 18MB in size respectively, and that would add 9MB to the installation size, but I find that acceptable.

[Byron]

I spiked it and think that doing so only benefits installation if links are used, overall compile time should then be lower, as well as the overall size on disk.

However, for CI it would then take longer as it rebuilds gix with varying compile flags, and to do that it would then need to compile ein (or its code) as well. I kept the experiment in the codebase though as I think it one day has a place.