It is possible to avoid ODR violations :) We put the per-target code into unique namespaces, and export a function pointer to them.
We want to take one function and compile it twice:
``` namespace MEGA_MACRO {
void foo(std::span<int> s) { super_awesome_platform_specific_thing(s); }
} // namespace MEGA_MACRO ```
Whatever you do - the code above has to be written once but compiled twice. In one file/in many files - doesn't matter.
My point is - I don't think you can compile that code twice if you support modules.
Then we have a table of function pointers to &AVX2::foo, &AVX3::foo etc. As long as the module exports one single thing, which either calls into or exports this table, I do not see how it is incompatible with building your project using modules enabled?
(The way we compile the code twice is to re-include our source file, taking care that only the SIMD parts are actually seen by the compiler, and stuff like the module exports would only be compiled once.)
Yeah - that means your source file is never a module. We would really like eve to be modularized, the CI times are unbearable.
I'd love to be proven wrong here, that'd be amazing. But I don't think google highway can be modularized.
Thus it ought to be possible, though I have not yet tried it.
You have a file, something like: load.h
You need to include it multiple times, compiled with different flags.
So - it's never going to be in load.cxx or whatever that's called.
Here is an example: https://github.com/google/gemma.cpp/blob/9dfe2a76be63bcfe679...
Let's stop here, it doesn't seem like we understand each other.