This question is referring to the “Modules in C++” proposals floating around, and more broadly to C like languages that need a similar feature (like my toy language I’m currently… toying with). In my world, “header files” do not exist, forward declarations would be a pest to maintain when writing any kind of code, and a single module can consist of several source files.
The problem is as follows:
Source file A uses a function or class from source file B, in the same module currently being compiled.
Why is this a problem?
- There is no module file for the things contained in file B, it will be generated when all source files are compiled.
- I do not want to compile file B twice, nor force all files in a module to be compiled at the same time. This is to keep the eventual build simple and easy.
- I do not want the user to be forced to compile file B first. I’m not saying cyclic dependencies should be allowed, I just want to be able to compile both files in parallel. Heck, automatic determination of the necessary compile order would imply compiling files more than once, which is something I’d like to avoid at all costs.
Any thoughts and of course solutions are very welcome!
Forgetting cycles… (which is the part I like thinking about most):
Automatic determination of the necessary compile order DOES NOT imply compiling files more than once.
All it requires is detecting if the file B that A depends on has (a) already been compiled, or (b) is in the process of being compiled, or (c) has not started being compiled yet. And I suppose (d) you might not have planned to compile B at all.
If (a), fine, no problemo.
If any other case, the compilation of A must be suspended until the compilation of B has been completed. That’s all.
I assume that you have some sort of parallel job manager or scheduler. If (d), you tell the job manager to schedule the compilation of B. If (c), you tell it to make the compilation of B higher priority than it already is. If (b), you just wait under the compilation of B that is already under way is done, and/or suspend the compilation of A, possibly switch to doing something else, until the compilation of B is finished.
If you don’t have a sophisticated job manager, possibly just make -j 8, you might get into deadlock, because all of your 8 parallel jobs might be waiting on some dependent. In which case you might have to stop one of them, and latyer restart it completely.
But if you have a job manager that supports putting any number if jobs to sleep, then you do not need to compile twice. (Barring cycles, which require relaxation.)
I’m tempted to suggest that you remember the dependency graph from one compile to the next recompile. That would be a good heuristic. And simple not-quite-full compilation stuff like scanning for #includes might help get the right order. But you might regard that as against the spirit.