GCC使用手记

# define likely(x)      __builtin_expect(!!(x), 1)
# define unlikely(x)    __builtin_expect(!!(x), 0)

#if __GNUC__ >= 3
# define __glibc_unlikely(cond) __builtin_expect ((cond), 0)
# define __glibc_likely(cond)   __builtin_expect ((cond), 1)
#else
# define __glibc_unlikely(cond) (cond)
# define __glibc_likely(cond)   (cond)
#endif

#include <stdio.h>

int func_expect_0(int i)
{
        int result;

        if (__builtin_expect(i > 2, 0)) {
                result = 100;
        } else {
                result = 200;
        }

        return result;
}

int func_expect_1(int i)
{
        int result;

        if (__builtin_expect(i > 4, 1)) {
                result = 100;
        } else {
                result = 200;
        }

        return result;
}

int main(int argc, char **argv)
{

        int ret1, ret2;

        ret1 = func_expect_0(argc);
        ret2 = func_expect_1(argc);

        printf("ret1=%d, ret2=%d\n", ret1, ret2);

        return 0;
}

        .globl  func_expect_0
        .def    func_expect_0;  .scl    2;      .type   32;     .endef
        .seh_proc       func_expect_0
func_expect_0:
        .seh_endprologue
        cmpl    $2, %ecx
        jg      .L4
        movl    $200, %eax
.L1:
        ret
.L4:
        movl    $100, %eax
        jmp     .L1
        .seh_endproc
        .globl  func_expect_1
        .def    func_expect_1;  .scl    2;      .type   32;     .endef
        .seh_proc       func_expect_1
func_expect_1:
        .seh_endprologue
        cmpl    $4, %ecx
        jle     .L7
        movl    $100, %eax
.L5:
        ret
.L7:
        movl    $200, %eax
        jmp     .L5
        .seh_endproc

~$ gcc -Og -o builtin_expect builtin_expect.c
~$ objdump -d builtin_expect
...
00000000000006b0 <func_expect_0>:
 6b0:   83 ff 02                cmp    $0x2,%edi
 6b3:   7f 06                   jg     6bb <func_expect_0+0xb>
 6b5:   b8 c8 00 00 00          mov    $0xc8,%eax
 6ba:   c3                      retq
 6bb:   b8 64 00 00 00          mov    $0x64,%eax
 6c0:   c3                      retq

00000000000006c1 <func_expect_1>:
 6c1:   83 ff 04                cmp    $0x4,%edi
 6c4:   7e 06                   jle    6cc <func_expect_1+0xb>
 6c6:   b8 64 00 00 00          mov    $0x64,%eax
 6cb:   c3                      retq
 6cc:   b8 c8 00 00 00          mov    $0xc8,%eax
 6d1:   c3                      retq
...

~$ cc -DDONT_EXPECT -O3 builtin_expect_test.c -o bn
~$ /usr/bin/time -f "%E real, %U user, %S sys" ./bn 1000
0, 1000000000
0:01.43 real, 1.42 user, 0.00 sys

~$ cc -DEXPECT_RESULT=0 -O3 builtin_expect_test.c -o b0
~$ /usr/bin/time -f "%E real, %U user, %S sys" ./b0 1000
0, 1000000000
0:01.41 real, 1.41 user, 0.00 sys

~$ cc -DEXPECT_RESULT=1 -O3 builtin_expect_test.c -o b1
~$ /usr/bin/time -f "%E real, %U user, %S sys" ./b1 1000
0, 1000000000
0:01.40 real, 1.40 user, 0.00 sys

Built-in Function: long __builtin_expect (long exp, long c)
You may use __builtin_expect to provide the compiler with branch prediction information. In general, you should prefer to use actual profile feedback for this (-fprofile-arcs), as programmers are notoriously bad at predicting how their programs actually perform. However, there are applications in which this data is hard to collect.

The return value is the value of exp, which should be an integral expression. The semantics of the built-in are that it is expected that exp == c. For example:

if (__builtin_expect (x, 0))
  foo ();
indicates that we do not expect to call foo, since we expect x to be zero. Since you are limited to integral expressions for exp, you should use constructions such as

if (__builtin_expect (ptr != NULL, 1))
  foo (*ptr);
when testing pointer or floating-point values.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

unsigned long mcount = 0;

extern void * __real_malloc(size_t size);
extern void  __real_free(void *ptr);

void *__wrap_malloc(size_t size)
{
        void *ptr = __real_malloc(size);

        if (ptr)
                ++mcount;

        printf("wrap malloc ptr=%p, size=%zu, count=%lu\n", ptr, size, mcount);

        return ptr;
}

void __wrap_free(void *ptr)
{
        __real_free(ptr);
        if (ptr)
                --mcount;
        printf("wrap free   ptr=%p, count=%lu\n", ptr, mcount);
}

int main(int argc, char *argv[argc])
{
        int *pi;

        pi = malloc(sizeof(*pi)*10);
        memset(pi, 0, sizeof(*pi)*10);
        free(pi);

        return 0;
}