User directed Function Multiversioning (MV) via Function Overloading

[Sriraman Tallam <tmsriram at google dot com>]

Hi,

User directed Function Multiversioning (MV) via Function Overloading
===================================================

I have created a set of patches to add support for user directed
function MV via function overloading. This was discussed in this
thread previously:
http://gcc.gnu.org/ml/gcc-patches/2011-04/msg02285.html

Two patches have been created now to support this:
* The patch with the front-end changes to support versioned functions is:
 http://codereview.appspot.com/5752064/

* The patch to add runtime CPU type detection support is here:
 http://codereview.appspot.com/5754058/

With this support, here is an example of writing a program with
function versions:

int foo ();  /* Default version */
int foo () __attribute__ ((targetv("arch=corei7"))); /*Specialized for corei7 */
int foo () __attribute__ ((targetv("arch=amdfam10"))); /*Specialized
for amdfam10 */

int main ()
{
  int (*p)() = &foo;
  return foo () + (*p)();
}

int foo ()
{
  return 0;
}

int __attribute__ ((targetv("arch=corei7")))
foo ()
{
  ...
  return 0;
}

int __attribute__ ((targetv("arch=amdfam10")))
foo ()
{
  ...
  return 0;
}

The above example has foo defined 3 times, but all 3 definitions of
foo are different versions of the same function. The call to foo in
main, directly and via a pointer, are calls to the multi-versioned
function foo which is dispatched to the right foo at run-time.

Function versions must have the same signature but must differ in the
specifier string provided to a new attribute called "targetv", which
is nothing but the target attribute with an extra specification to
indicate a version. Any number of versions can be created using the
targetv attribute but it is mandatory to have one function without the
attribute, which is treated as the default version. The front-end
support is available in this patch:
 http://codereview.appspot.com/5752064/

The front-end treats multiple definitions of foo with the same
signature but with different targetv attributes as legitimate
candidates for overloading. Also, all the function versions of one
function are grouped together. Then, calls to foo and pointer access
of foo will be replaced by an IFUNC function (foo.ifunc) which will
call the dispatcher code at run-time to figure out the right version
to execute. For the above example, the following functions will be
created :

* _Z3foov.ifunc : ifunc dispatcher for multi-versioned function foo and
  aliases to _Z3foov.resolver. All calls and pointer accesses to foo are
  replaced by an call or pointer access to this function.
* _Z3foov.resolver : The code to determine which version to execute at
  run-time.
* _Z3foov : The default version of foo.
* _Z3foov.arch_corei7 : The corei7 version of foo.
* _Z3foov.arch_amdfam10 : The amdfam10 version of foo.

Note that using IFUNC  blocks inlining of versioned functions. I had
implemented an optimization earlier to do hot path cloning to allow
versioned functions to be inlined. Please see :
http://gcc.gnu.org/ml/gcc-patches/2011-04/msg02285.html
In the next iteration, I plan to merge these two. With that, hot code
paths with versioned functions will be cloned so that versioned
functions can be inlined.

The version dispatch itself happens in a newly created pass added to
be one of the initial lowering passes. The pass communicates with the
target to determine the appropriate predicates to use to figure out
which version to dispatch at run-time. The predicates are target
builtins which determine the platform type at run-time and are added
in this patch :
http://codereview.appspot.com/5754058/

The following features are being developed for the next iteration:

1) Support for hot path cloning to inline versioned functions.
2) Specifying multiple versions in a single function definition.

This will be done using the following syntax:
int foo ()
__attribute__ ((targetv (("arch=corei7"),("arch=amdfam10"), ("arch=core2"))));

which means the same body of foo must be cloned for corei7, amdfam10, and core2.

3) Specifying ISA types in the attribute. Only "arch=" is supported now.

For example,
int foo ()
__attribute__ ((targetv ("popcnt,ssse3")));

means the version is only to be executed when popcount and ssse3
instructions are available.

4) Other dispatching mechanism.

IFUNC is used for dispatch, but then the target does not support this
dispatching by directly calling the appropriate function version after
checking the platform type will be supported.

5) Virtual function versioning.

Thoughts?

Thanks,
-Sri.