linux-imx

===========

Static Keys

===========

​

.. warning::

​

   DEPRECATED API:

​

   The use of 'struct static_key' directly, is now DEPRECATED. In addition

   static_key_{true,false}() is also DEPRECATED. IE DO NOT use the following::

​

    struct static_key false = STATIC_KEY_INIT_FALSE;

    struct static_key true = STATIC_KEY_INIT_TRUE;

    static_key_true()

    static_key_false()

​

   The updated API replacements are::

​

    DEFINE_STATIC_KEY_TRUE(key);

    DEFINE_STATIC_KEY_FALSE(key);

    DEFINE_STATIC_KEY_ARRAY_TRUE(keys, count);

    DEFINE_STATIC_KEY_ARRAY_FALSE(keys, count);

    static_branch_likely()

    static_branch_unlikely()

​

Abstract

========

​

Static keys allows the inclusion of seldom used features in

performance-sensitive fast-path kernel code, via a GCC feature and a code

patching technique. A quick example::

​

    DEFINE_STATIC_KEY_FALSE(key);

​

    ...

​

        if (static_branch_unlikely(&key))

                do unlikely code

        else

                do likely code

​

    ...

    static_branch_enable(&key);

    ...

    static_branch_disable(&key);

    ...

​

The static_branch_unlikely() branch will be generated into the code with as little

impact to the likely code path as possible.

​

​

Motivation

==========

​

​

Currently, tracepoints are implemented using a conditional branch. The

conditional check requires checking a global variable for each tracepoint.

Although the overhead of this check is small, it increases when the memory

cache comes under pressure (memory cache lines for these global variables may

be shared with other memory accesses). As we increase the number of tracepoints

in the kernel this overhead may become more of an issue. In addition,

tracepoints are often dormant (disabled) and provide no direct kernel

functionality. Thus, it is highly desirable to reduce their impact as much as

possible. Although tracepoints are the original motivation for this work, other

kernel code paths should be able to make use of the static keys facility.

​

​

Solution

========

​

​

gcc (v4.5) adds a new 'asm goto' statement that allows branching to a label:

​

http://gcc.gnu.org/ml/gcc-patches/2009-07/msg01556.html

​

Using the 'asm goto', we can create branches that are either taken or not taken

by default, without the need to check memory. Then, at run-time, we can patch

the branch site to change the branch direction.

​

For example, if we have a simple branch that is disabled by default::

​

    if (static_branch_unlikely(&key))

        printk("I am the true branch\n");

​

Thus, by default the 'printk' will not be emitted. And the code generated will

consist of a single atomic 'no-op' instruction (5 bytes on x86), in the

straight-line code path. When the branch is 'flipped', we will patch the

'no-op' in the straight-line codepath with a 'jump' instruction to the

out-of-line true branch. Thus, changing branch direction is expensive but

branch selection is basically 'free'. That is the basic tradeoff of this

optimization.

​