[Modules] Increased build times across translation units in O0

[koplas]

Given the following translation units:

export module a;

export namespace a {
    int a_0() {return 0;}
    int a_1() {return 0;}
    int a_2() {return 0;}
...
    int a_1000000() {return 0;}
}

export module b;
import a;

export namespace b {
    int b() {
        return 1;
    }
}

export module c;
import b;

export namespace c {
    int c() {
        return b::b();
    }
}

And running the following:

echo "Building a.cppm"
time clang++ -std=c++20 --precompile a.cppm -o a.pcm
time clang++ -std=c++20 a.cppm -c -o a.o
echo "Building b.cppm"
time clang++ -std=c++20 -fprebuilt-module-path=. --precompile b.cppm -o b.pcm
time clang++ -std=c++20 -fprebuilt-module-path=. b.cppm -c -o b.o
echo "Building c.cppm"
time clang++ -std=c++20 -fprebuilt-module-path=. --precompile c.cppm -o c.pcm
time clang++ -std=c++20 -fprebuilt-module-path=. c.cppm -c -o c.o

Results in this output:

Building a.cppm

real    0m25,961s
user    0m24,515s
sys     0m1,337s

real    1m23,304s
user    1m20,309s
sys     0m2,856s

Building b.cppm

real    0m2,201s
user    0m1,978s
sys     0m0,220s

real    0m5,779s
user    0m5,373s
sys     0m0,400s

Building c.cppm

real    0m2,146s
user    0m1,957s
sys     0m0,187s

real    0m5,714s
user    0m5,317s
sys     0m0,389s

As expected the build times of a.cppm is high. However, even the build of c.cppm takes a lot of time.
Note that in the pre-compiling phase of b.cppm and c.cppm circa 200 ms is spent in WriteAst, despite not having many lines of code.

build-times-test.zip

[llvmbot]

@llvm/issue-subscribers-clang-modules

[ChuanqiXu9]

This should be duplicated with #60996

[ChuanqiXu9]

Oh, sorry. This is not duplicated with #60996 since that issues focus on the optimization mode and this issue is not related to optimizations.

[ChuanqiXu9]

Here are more profiled information for this: https://discourse.llvm.org/t/modules-increased-build-times/68755/6

[koplas]

My bad, I should have been more explicit.

[ChuanqiXu9]

@koplas Now b and c should compile quickly (less than 0.1s) after the above patch.

I expected this can produce a strong impact on modular codes. However, in a realworld local modularized project, I only found this patch can produce 3% improvements. It makes sense in some level since the reproducer is in the very edging case. Could you help to test clang again in your project and share the profile results in the above link? Thanks in advance.