Compiler Multiverse support
This page documents the proposal for a compile feature to enable run time multiverse support.
gcc could be extended to generalize the binary patching technique used in the Linux kernel for use for any application. What this provides is variable optimized run time multiverse support.
Technical feasibility
Its known in theory this should technically be possible given that:
- variable attributes exist, this would be used
- functions can be cloned, even with special variable settings
Example
Let's consider the simple case of using a bool which only has two possible values:
- true
- false
Code that would want to make use of this would annotate that the bool can be optimized for binary patching using a special attribute, for instance:
static __attribute__((multiverse)) bool some_value;
int foo(void)
{
if (some_value) {
do_a();
} else {
do_b();
}
}
int main(int argc, char **argv)
{
if (argc > 1)
some_value = true;
gcc_runtime_optimize_variable(&some_value);
}In this example when gcc would see some_value has the multiverse annotation, it would clone the foo() function twice, for two different possible universes, one where some_val is true, and one where some_val is false. The references to the some_val locations in code are also stored for later use (generic some_val use, where some_val = true, some_val = false) in a special section to allow for run time patching.
Applications get to hint during run time when a variable is deemed stable, this means that the variable value will not change for either:
- a very long time
- forever
If an application, or the kernel, determines that a configuration variable is now deemed "stable", it can enable the application to put itself into an application specific safe state (for instance perhaps disallow concurrent threads, disable preemption, perhaps machine_stop() in the kernel). After this application specific safe-state call, a generic function would be called that would run time patch either the first few bytes of some generic functions or all invocations of the generic functions with the specialized variant for the current value of some_val.
Benefits
Benefits once this happens:
- code executes and performs runs as efficienbtly as if some_val would have just been a const bool, or as if some_val would never had needed to be runtime determined
- no register clobbering
- no [id]cache pollution
ability to identify and compartmentalize dead-code
- ability to decide how to handle dead-code at run time:
freeing unused code after variable stable state is reached
- ability to enable debugging phase to ensure code that should not runs does not run, for instance by marking dead-code as not present
Negative effects
Expected negative effects to consider:
- function cloning would increase the final size of a binary
- due to size impact, use of this functionality should be limited
Potential uses
Expected potential uses:
- Linux's UP/SMP patching
- Linux's pv-ops
- Linux's alternative patching based on cpu features
- QEMU's kvm_enabled(), xen_enabled(), etc
- user space JIT with runtime cpu feature detection
- anything that wants to optimize for cpu features
- dpdk network filter features
Feature inception
This idea was suggested by Alexander Graf while discussing an alternative to [http://kernelnewbies.org/KernelProjects/kernel-sandboxing Linker Table solution] with Luis Rodriguez to address [http://kernelnewbies.org/KernelProjects/kernel-sandboxing dead code] in the Linux kernel. This is a development idea for an extension to gcc to generalize dead-code support with compiler support.
Interested developers
If you are interested in helping complete it on gcc please reach out to: