initcall: Move to inline function
PATCH 1/1 initcall: Move to inline function
The board_r init function was complaining that we are looping through an array, calling all our tiny init stubs sequentially via indirect function calls (which can't be speculated, so they are slow).
The solution to that is pretty easy though. All we need to do is inline the function that loops through the functions and the compiler will automatically convert almost all indirect calls into direct inlined code.
With this patch, the overall code size drops (by 40 bytes on riscv64) and boot time should become measurably faster for every target.
--- common/board_r.c | 5 +---- include/initcall.h | 35 ++++++++++++++++++++++++++++++++++- lib/Makefile | 1 - lib/initcall.c | 39 --------------------------------------- 4 files changed, 35 insertions(+), 45 deletions(-) delete mode 100644 lib/initcall.c
common/board_r.c +1 -4
@@ -633,10 +633,7 @@ static int run_main_loop(void) }/* -* Over time we hope to remove these functions with code fragments and -* stub functions, and instead call the relevant function directly. -* -* We also hope to remove most of the driver-related init and do it if/when +* We hope to remove most of the driver-related init and do it if/when * the driver is later used. * * TODO: perhaps reset the watchdog in the initcall function after each call?
include/initcall.h +34 -1
@@ -8,6 +8,39 @@typedef int (*init_fnc_t )(void ); -int initcall_run_list (const init_fnc_t init_sequence[]); +#include <common.h> +#include <initcall.h> +#include <efi.h> + +DECLARE_GLOBAL_DATA_PTR ; + +static inline int initcall_run_list (const init_fnc_t init_sequence[]) +{ +const init_fnc_t *init_fnc_ptr; + +for (init_fnc_ptr = init_sequence; *init_fnc_ptr; ++init_fnc_ptr) { +unsigned long reloc_ofs =0 ; +int ret; + +if (gd->flags &GD_FLG_RELOC ) + reloc_ofs = gd->reloc_off; +#ifdef CONFIG_EFI_APP + reloc_ofs = (unsigned long )image_base; +#endif +debug ("initcall: %p" , (char *)*init_fnc_ptr - reloc_ofs); +if (gd->flags &GD_FLG_RELOC ) +debug (" (relocated to %p)\n" , (char *)*init_fnc_ptr); +else +debug ("\n" ); + ret = (*init_fnc_ptr)(); +if (ret) { +printf ("initcall sequence %p failed at call %p (err=%d)\n" , + init_sequence, + (char *)*init_fnc_ptr - reloc_ofs, ret); +return -1 ; + } + } +return 0 ; +}#endif
lib/Makefile +0 -1
@@ -35,7 +35,6 @@ obj-$(CONFIG_TEST_FDTDEC) += fdtdec_test.o obj-$(CONFIG_GZIP_COMPRESSED) += gzip.o obj-$(CONFIG_GENERATE_SMBIOS_TABLE) += smbios.o obj-$(CONFIG_IMAGE_SPARSE) += image-sparse.o -obj-y += initcall.o obj-y += ldiv.o obj-$(CONFIG_MD5) += md5.o obj-y += net_utils.o
lib/initcall.c deleted +0 -39
@@ -1,39 +0,0 @@ -// SPDX-License-Identifier: GPL-2.0+ -/* -* Copyright (c) 2013 The Chromium OS Authors. -*/ - -#include <common.h> -#include <initcall.h> -#include <efi.h> - -DECLARE_GLOBAL_DATA_PTR ; - -int initcall_run_list (const init_fnc_t init_sequence[]) -{ -const init_fnc_t *init_fnc_ptr; - -for (init_fnc_ptr = init_sequence; *init_fnc_ptr; ++init_fnc_ptr) { -unsigned long reloc_ofs =0 ; -int ret; - -if (gd->flags &GD_FLG_RELOC ) - reloc_ofs = gd->reloc_off; -#ifdef CONFIG_EFI_APP - reloc_ofs = (unsigned long )image_base; -#endif -debug ("initcall: %p" , (char *)*init_fnc_ptr - reloc_ofs); -if (gd->flags &GD_FLG_RELOC ) -debug (" (relocated to %p)\n" , (char *)*init_fnc_ptr); -else -debug ("\n" ); - ret = (*init_fnc_ptr)(); -if (ret) { -printf ("initcall sequence %p failed at call %p (err=%d)\n" , - init_sequence, - (char *)*init_fnc_ptr - reloc_ofs, ret); -return -1 ; - } - } -return 0 ; -}
Signature · 1 line
2.12.3
PATCH 1/1 initcall: Move to inline function
Hi Alex,
Quoted 4 lines · Alexander Graf
The
board_rinit function was complaining that we are looping through an array, calling all our tiny init stubs sequentially via indirect function calls (which can't be speculated, so they are slow).
Is this a compiler warning? Could you let me know what this is?
Quoted 4 lines
The solution to that is pretty easy though. All we need to do is inline the function that loops through the functions and the compiler will automatically convert almost all indirect calls into direct inlined code.
You mean it calls the functions one after the other without a function-table array?
Quoted 4 lines
With this patch, the overall code size drops (by 40 bytes on riscv64) and boot time should become measurably faster for every target.
Quoted 9 lines
Signed-off-by Alexander Graf <[email protected]>--- common/board_r.c | 5 +---- include/initcall.h | 35 ++++++++++++++++++++++++++++++++++- lib/Makefile | 1 - lib/initcall.c | 39 --------------------------------------- 4 files changed, 35 insertions(+), 45 deletions(-) delete mode 100644 lib/initcall.c
Regards,
Simon
PATCH 1/1 initcall: Move to inline function
Quoted 6 lines
Am 02.02.2019 um 15:13 schrieb Simon Glass <[email protected]>:
Hi Alex,
Quoted 7 lines
Quoted 5 lines · Alexander Graf
The
board_rinit function was complaining that we are looping through an array, calling all our tiny init stubs sequentially via indirect function calls (which can't be speculated, so they are slow).Is this a compiler warning? Could you let me know what this is?
It's the code comment I'm removing with this patch :).
Quoted 8 lines
Quoted 5 lines
The solution to that is pretty easy though. All we need to do is inline the function that loops through the functions and the compiler will automatically convert almost all indirect calls into direct inlined code.
You mean it calls the functions one after the other without a function-table array?
Exactly. Magical, eh? It even inlines them!
Alex
Quoted 17 lines
Quoted 5 lines
With this patch, the overall code size drops (by 40 bytes on riscv64) and boot time should become measurably faster for every target.
Quoted 9 lines
Signed-off-by Alexander Graf <[email protected]>---
common/board_r.c | 5 +---- include/initcall.h | 35 ++++++++++++++++++++++++++++++++++- lib/Makefile | 1 - lib/initcall.c | 39 --------------------------------------- 4 files changed, 35 insertions(+), 45 deletions(-)delete mode 100644
lib/initcall.cRegards,
Simon
PATCH 1/1 initcall: Move to inline function
Hi Alex,
Quoted 19 lines · Alexander Graf
Quoted 7 lines
Am 02.02.2019 um 15:13 schrieb Simon Glass <[email protected]>:
Hi Alex,
Quoted 7 lines
Quoted 5 lines · Alexander Graf
The
board_rinit function was complaining that we are looping through an array, calling all our tiny init stubs sequentially via indirect function calls (which can't be speculated, so they are slow).Is this a compiler warning? Could you let me know what this is?
It's the code comment I'm removing with this patch :).
Quoted 2 lines
Quoted 2 lines
Quoted 8 lines
Quoted 6 lines
Quoted 3 lines
The solution to that is pretty easy though. All we need to do is inline the function that loops through the functions and the compiler will automatically convert almost all indirect calls into direct inlined code.
You mean it calls the functions one after the other without a function-table array?
Exactly. Magical, eh? It even inlines them!
Yes it is surprising. I am also surprised that it reduces code size, but I suppose that is why it does it. Presumably the inlining is what does that.
But what happens if we #define DEBUG?
Regards,
Simon
PATCH 1/1 initcall: Move to inline function
Quoted 30 lines
Am 08.02.2019 um 05:11 schrieb Simon Glass <[email protected]>:
Hi Alex,
Quoted 24 lines · Alexander Graf
Quoted 7 lines
Am 02.02.2019 um 15:13 schrieb Simon Glass <[email protected]>:
Hi Alex,
Quoted 7 lines
Quoted 5 lines · Alexander Graf
The
board_rinit function was complaining that we are looping through an array, calling all our tiny init stubs sequentially via indirect function calls (which can't be speculated, so they are slow).Is this a compiler warning? Could you let me know what this is?
It's the code comment I'm removing with this patch :).
Quoted 6 lines
Quoted 5 lines
The solution to that is pretty easy though. All we need to do is inline the function that loops through the functions and the compiler will automatically convert almost all indirect calls into direct inlined code.
Quoted 8 lines
Quoted 4 lines
Quoted 2 lines
You mean it calls the functions one after the other without a function-table array?
Exactly. Magical, eh? It even inlines them!
Yes it is surprising. I am also surprised that it reduces code size, but I suppose that is why it does it. Presumably the inlining is what does that.
Yes, of course. With separate object files, the compiler can not inline anything at all, because it does not know how the function pointers get used.
The alternative to this *might* be LTO, which we could think about as well. It should help reduce indirection and code size overall. But I don't know how well gold works with the linker scripts we have.
Quoted 1 line
But what happens if we #define DEBUG?
Define it where? ;)
Alex
Quoted 3 lines
Regards,
Simon
PATCH 1/1 initcall: Move to inline function
Hi Alex,
Quoted 36 lines · Alexander Graf
Quoted 36 lines
Am 08.02.2019 um 05:11 schrieb Simon Glass <[email protected]>:
Hi Alex,
Quoted 28 lines · Alexander Graf
Quoted 7 lines
Am 02.02.2019 um 15:13 schrieb Simon Glass <[email protected]>:
Hi Alex,
Quoted 7 lines
Quoted 5 lines · Alexander Graf
The
board_rinit function was complaining that we are looping through an array, calling all our tiny init stubs sequentially via indirect function calls (which can't be speculated, so they are slow).Is this a compiler warning? Could you let me know what this is?
It's the code comment I'm removing with this patch :).
Quoted 8 lines
Quoted 5 lines
The solution to that is pretty easy though. All we need to do is inline the function that loops through the functions and the compiler will automatically convert almost all indirect calls into direct inlined code.
You mean it calls the functions one after the other without a function-table array?
Exactly. Magical, eh? It even inlines them!
Quoted 7 lines
Quoted 3 lines
Yes it is surprising. I am also surprised that it reduces code size, but I suppose that is why it does it. Presumably the inlining is what does that.
Yes, of course. With separate object files, the compiler can not inline anything at all, because it does not know how the function pointers get used.
The alternative to this *might* be LTO, which we could think about as well. It should help reduce indirection and code size overall. But I don't know how well gold works with the linker scripts we have.
Hmm don't we have that? We should.
Quoted 4 lines
Quoted 2 lines
But what happens if we #define DEBUG?
Define it where? ;)
Yes exactly. At present you can turn this on globally by putting it at the top of initcall.c. I think it is worth a comment on how to enable debugging.
Does the code size blow out horribly if debugging is enabled?
(and hello from Munich!)
Regards,
Simon
PATCH 1/1 initcall: Move to inline function
In reply to Alexander GrafQuoted 39 lines · Alexander Graf
Quoted 30 lines
Am 08.02.2019 um 05:11 schrieb Simon Glass <[email protected]>:
Hi Alex,
Quoted 24 lines · Alexander Graf
Quoted 7 lines
Am 02.02.2019 um 15:13 schrieb Simon Glass <[email protected]>:
Hi Alex,
Quoted 7 lines
Quoted 5 lines · Alexander Graf
The
board_rinit function was complaining that we are looping through an array, calling all our tiny init stubs sequentially via indirect function calls (which can't be speculated, so they are slow).Is this a compiler warning? Could you let me know what this is?
It's the code comment I'm removing with this patch :).
Quoted 6 lines
Quoted 5 lines
The solution to that is pretty easy though. All we need to do is inline the function that loops through the functions and the compiler will automatically convert almost all indirect calls into direct inlined code.
Quoted 8 lines
Quoted 4 lines
Quoted 2 lines
You mean it calls the functions one after the other without a function-table array?
Exactly. Magical, eh? It even inlines them!
Yes it is surprising. I am also surprised that it reduces code size, but I suppose that is why it does it. Presumably the inlining is what does that.
Quoted 7 lines
Yes, of course. With separate object files, the compiler can not inline anything at all, because it does not know how the function pointers get used.
The alternative to this *might* be LTO, which we could think about as well. It should help reduce indirection and code size overall. But I don't know how well gold works with the linker scripts we have.
I don't object to LTO but there's a LOT of groundwork before it's an option. I think in addition to switching to gcc for ld, looking over an old git stash from when I tried this last, we need to globally switch to the "clang" method of keeping track of gd rather than how we do it today.
Signature · 8 lines
Tom -------------- next part -------------- A non-text attachment was scrubbed... Name: signature.asc Type: application/pgp-signature Size: 819 bytes Desc: not available URL: <http://lists.denx.de/pipermail/u-boot/attachments/20190210/d72102b3/attachment.sig>
PATCH 1/1 initcall: Move to inline function
Quoted 52 lines
Am 10.02.2019 um 14:16 schrieb Tom Rini <[email protected]>:
Quoted 40 lines · Alexander Graf
Quoted 30 lines
Am 08.02.2019 um 05:11 schrieb Simon Glass <[email protected]>:
Hi Alex,
Quoted 24 lines · Alexander Graf
Quoted 7 lines
Am 02.02.2019 um 15:13 schrieb Simon Glass <[email protected]>:
Hi Alex,
Quoted 7 lines
Quoted 5 lines · Alexander Graf
The
board_rinit function was complaining that we are looping through an array, calling all our tiny init stubs sequentially via indirect function calls (which can't be speculated, so they are slow).Is this a compiler warning? Could you let me know what this is?
It's the code comment I'm removing with this patch :).
Quoted 6 lines
Quoted 5 lines
The solution to that is pretty easy though. All we need to do is inline the function that loops through the functions and the compiler will automatically convert almost all indirect calls into direct inlined code.
Quoted 8 lines
Quoted 4 lines
Quoted 2 lines
You mean it calls the functions one after the other without a function-table array?
Exactly. Magical, eh? It even inlines them!
Yes it is surprising. I am also surprised that it reduces code size, but I suppose that is why it does it. Presumably the inlining is what does that.
Quoted 7 lines
Yes, of course. With separate object files, the compiler can not inline anything at all, because it does not know how the function pointers get used.
The alternative to this *might* be LTO, which we could think about as well. It should help reduce indirection and code size overall. But I don't know how well gold works with the linker scripts we have.
Quoted 5 lines
I don't object to LTO but there's a LOT of groundwork before it's an option. I think in addition to switching to gcc for ld, looking over an old git stash from when I tried this last, we need to globally switch to the "clang" method of keeping track of gd rather than how we do it today.
Sounds like x86_64 could be an easy target for experimentation then? :)
Alex
Quoted 3 lines
Signature · 2 lines
-- Tom
PATCH 1/1 initcall: Move to inline function
Quoted 52 lines · Alexander Graf
Quoted 52 lines
Am 10.02.2019 um 14:16 schrieb Tom Rini <[email protected]>:
Quoted 47 lines · Alexander Graf
Quoted 30 lines
Am 08.02.2019 um 05:11 schrieb Simon Glass <[email protected]>:
Hi Alex,
Quoted 24 lines · Alexander Graf
Quoted 7 lines
Am 02.02.2019 um 15:13 schrieb Simon Glass <[email protected]>:
Hi Alex,
Quoted 7 lines
Quoted 5 lines · Alexander Graf
The
board_rinit function was complaining that we are looping through an array, calling all our tiny init stubs sequentially via indirect function calls (which can't be speculated, so they are slow).Is this a compiler warning? Could you let me know what this is?
It's the code comment I'm removing with this patch :).
Quoted 6 lines
Quoted 5 lines
The solution to that is pretty easy though. All we need to do is inline the function that loops through the functions and the compiler will automatically convert almost all indirect calls into direct inlined code.
Quoted 8 lines
Quoted 4 lines
Quoted 2 lines
You mean it calls the functions one after the other without a function-table array?
Exactly. Magical, eh? It even inlines them!
Yes it is surprising. I am also surprised that it reduces code size, but I suppose that is why it does it. Presumably the inlining is what does that.
Yes, of course. With separate object files, the compiler can not inline anything at all, because it does not know how the function pointers get used.
The alternative to this *might* be LTO, which we could think about as well. It should help reduce indirection and code size overall. But I don't know how well gold works with the linker scripts we have.
Quoted 7 lines
Quoted 5 lines
I don't object to LTO but there's a LOT of groundwork before it's an option. I think in addition to switching to gcc for ld, looking over an old git stash from when I tried this last, we need to globally switch to the "clang" method of keeping track of gd rather than how we do it today.
Sounds like
x86_64could be an easy target for experimentation then? :)
Could be? I tried ARM for some reason first.
Signature · 8 lines
Tom -------------- next part -------------- A non-text attachment was scrubbed... Name: signature.asc Type: application/pgp-signature Size: 819 bytes Desc: not available URL: <http://lists.denx.de/pipermail/u-boot/attachments/20190210/ab535185/attachment.sig>
Quoted 4 lines · Alexander Graf
The
board_rinit function was complaining that we are looping through an array, calling all our tiny init stubs sequentially via indirect function calls (which can't be speculated, so they are slow).
Quoted 8 lines
The solution to that is pretty easy though. All we need to do is inline the function that loops through the functions and the compiler will automatically convert almost all indirect calls into direct inlined code.
With this patch, the overall code size drops (by 40 bytes on riscv64) and boot time should become measurably faster for every target.
Signed-off-by Alexander Graf <[email protected]>
Applied to u-boot/master, thanks!
Signature · 8 lines
Tom -------------- next part -------------- A non-text attachment was scrubbed... Name: signature.asc Type: application/pgp-signature Size: 819 bytes Desc: not available URL: <http://lists.denx.de/pipermail/u-boot/attachments/20190210/f58e28a3/attachment.sig>