libuuid: improve uuid_unparse() performance
PATCH v2 1/1 libuuid: improve uuid_unparse() performance
There is 2 improvements:
* remove useless uuid_unpack,
* directly print the hexa format from memory without using printf we can do this as the bytes order is the network byte order
https://tools.ietf.org/html/rfc4122#section-4.1.2
even the spatially unique node identifier(the last 6 bytes)
The improvement is important, some results for 1000000 uuid_unparse calls:
Little Endian Ubuntu:
before took 382623 us
after took 36740 us
Big Endian OpenBSD:
before took 3138172 us
after took 180116 us
--- libuuid/src/unparse.c | 45 ++++++++++++++++++++----------------------- 1 file changed, 21 insertions(+), 24 deletions(-)
libuuid/src/unparse.c +21 -24
@@ -36,41 +36,38 @@#include "uuidP.h" -static const char *fmt_lower = -"%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x" ; +static char const hexdigits_lower[16 ] ="0123456789abcdef" ; +static char const hexdigits_upper[16 ] ="0123456789ABCDEF" ; -static const char *fmt_upper = -"%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X" ; - -#ifdef UUID_UNPARSE_DEFAULT_UPPER -#define FMT_DEFAULT fmt_upper -#else -#define FMT_DEFAULT fmt_lower -#endif - -static void uuid_unparse_x (const uuid_t uu,char *out,const char *fmt) +static void uuid_fmt (const uuid_t uuid,char *buf,char const fmt[restrict]) { -struct uuid uuid; +char *p = buf; -uuid_unpack (uu, &uuid); -sprintf (out, fmt, - uuid.time_low, uuid.time_mid, uuid.time_hi_and_version, - uuid.clock_seq >>8 , uuid.clock_seq &0xFF , - uuid.node[0 ], uuid.node[1 ], uuid.node[2 ], - uuid.node[3 ], uuid.node[4 ], uuid.node[5 ]); +for (int i =0 ; i <16 ; i++) { +if (i ==4 || i ==6 || i ==8 || i ==10 ) { + *p++ ='-' ; + } +size_t tmp = uuid[i]; + *p++ = fmt[tmp >>4 ]; + *p++ = fmt[tmp &15 ]; + } + *p ='\0' ; }void uuid_unparse_lower (const uuid_t uu,char *out) { -uuid_unparse_x (uu, out, fmt_lower); +uuid_fmt (uu, out, hexdigits_lower); }void uuid_unparse_upper (const uuid_t uu,char *out) { -uuid_unparse_x (uu, out, fmt_upper); +uuid_fmt (uu, out, hexdigits_upper); } +#ifdef UUID_UNPARSE_DEFAULT_UPPER void uuid_unparse (const uuid_t uu,char *out) -{ -uuid_unparse_x (uu, out,FMT_DEFAULT ); -} + __attribute__((alias ("uuid_unparse_upper" ))); +#else +void uuid_unparse (const uuid_t uu,char *out) + __attribute__((alias ("uuid_unparse_lower" ))); +#endif
Signature · 1 line
2.20.1
Quoted 2 lines · Aurelien LAJOIE
libuuid/src/unparse.c | 45 ++++++++++++++++++++----------------------- 1 file changed, 21 insertions(+), 24 deletions(-)
Applied, thanks.
Karel
Signature · 2 lines
Karel Zak <[email protected]> http://karelzak.blogspot.com
Karel Zak
maintainerlibuuid/src/unparse.c line 73
Quoted 10 lines · Aurelien LAJOIE
libuuid/src/unparse.c +6
-3+#ifdef UUID_UNPARSE_DEFAULT_UPPER void uuid_unparse (const uuid_t uu,char *out) -{ -uuid_unparse_x (uu, out,FMT_DEFAULT ); -} + __attribute__((alias ("uuid_unparse_upper" ))); +#else +void uuid_unparse (const uuid_t uu,char *out) + __attribute__((alias ("uuid_unparse_lower" ))); +#endif
The alias attribute is not portable to clang on Darwin.
I have replaced the aliases with function calls.
https://github.com/karelzak/util-linux/commit/bee464006776203a8cb545a35c86234181c7a55a
Karel
Signature · 2 lines
Karel Zak <[email protected]> http://karelzak.blogspot.com
Quoted 10 lines · Karel Zak
libuuid/src/unparse.c line 73
Quoted 5 lines · Aurelien LAJOIE
libuuid/src/unparse.c +5
-0+ __attribute__((alias("uuid_unparse_upper"))); +#else +void uuid_unparse (const uuid_t uu,char *out) + __attribute__((alias ("uuid_unparse_lower" ))); +#endif The alias attribute is not portable to clang on Darwin.
Quoted 5 lines
I have replaced the aliases with function calls.
https://github.com/karelzak/util-linux/commit/bee464006776203a8cb545a35c86234181c7a55a
Since Darwin does support weak_alias, can we just use that? Is it "strong enough"? I'm assuming nothing will override the alias so it can still have the same efficient end result, having both symbols resolve to the same address with no extra per-call overhead. (And without bloating the library from a compiler deciding to inline the static helper function into all 3 instead of 2 callers. Although most programs probably only ever call one, so only one has to stay hot in I-cache, with the others only bloating the file size and space in that iTLB memory page.)
Or can we put the wrapper function in a .h so it can inline away? That would bake the choice into applications that use libuuid, so you couldn't change it just by rebuilding libuuid. That's perhaps not desirable; if applications wanted to have that choice baked in they could have called the explicit upper or lower versions.
Karel Zak
maintainerQuoted 27 lines · Peter Cordes
Quoted 10 lines · Karel Zak
libuuid/src/unparse.c line 73
Quoted 5 lines · Aurelien LAJOIE
libuuid/src/unparse.c +5
-0+ __attribute__((alias("uuid_unparse_upper"))); +#else +void uuid_unparse (const uuid_t uu,char *out) + __attribute__((alias ("uuid_unparse_lower" ))); +#endif The alias attribute is not portable to clang on Darwin.
Quoted 5 lines
I have replaced the aliases with function calls.
https://github.com/karelzak/util-linux/commit/bee464006776203a8cb545a35c86234181c7a55a
Since Darwin does support
weak_alias, can we just use that? Is it "strong enough"? I'm assuming nothing will override the alias so it can still have the same efficient end result, having both symbols resolve to the same address with no extra per-call overhead. (And without bloating the library from a compiler deciding to inline the static helper function into all 3 instead of 2 callers. Although most programs probably only ever call one, so only one has to stay hot in I-cache, with the others only bloating the file size and space in that iTLB memory page.)
Quoted 5 lines
Or can we put the wrapper function in a .h so it can inline away? That would bake the choice into applications that use libuuid, so you couldn't change it just by rebuilding libuuid. That's perhaps not desirable; if applications wanted to have that choice baked in they could have called the explicit upper or lower versions.
Frankly, what we're trying to fix by the alias? It sounds like premature optimization. The current solution works, maybe foo(bar()) is also optimized by compiler. I have doubts that use inline function in header or so makes a real sense.
Karel
Signature · 2 lines
Karel Zak <[email protected]> http://karelzak.blogspot.com
Karel Zak
maintainerQuoted 11 lines · Karel Zak
Quoted 5 lines · Peter Cordes
Or can we put the wrapper function in a .h so it can inline away? That would bake the choice into applications that use libuuid, so you couldn't change it just by rebuilding libuuid. That's perhaps not desirable; if applications wanted to have that choice baked in they could have called the explicit upper or lower versions.
Frankly, what we're trying to fix by the alias? It sounds like premature optimization. The current solution works, maybe foo(bar()) is also optimized by compiler. I have doubts that use inline function in header or so makes a real sense.
BTW, would be better to make uuid_fmt() as inline function as we use it in uuid_unparse_lower(), uuid_unparse_upper() and uuid_unparse()?
Karel
Signature · 2 lines
Karel Zak <[email protected]> http://karelzak.blogspot.com
Quoted 1 line
Frankly, what we're trying to fix by the alias? It sounds like
premature optimization.
Reducing static code size / file size of the library by ~190 bytes or something like that IIRC for x86-64 for the current version, by avoiding a 3rd duplicate of the code (if the compiler inlines uuid_fmt()). Or reducing the cost of forcing it to inline for cases where the compiler chooses not to.
Quoted 3 lines · Karel Zak
BTW, would be better to make
uuid_fmt()as inline function as we use it inuuid_unparse_lower(),uuid_unparse_upper()anduuid_unparse()?
It's already static. The compiler is completely free to inline it into both (or all 3) callsites, depending on tuning heuristics. If we expect that only one of the 3 will normally be "hot" at the same time, then yeah forcing the issue with __attribute__((always_inline)) to make sure we don't get a jmp tailcall is nice.
In practice for x86-64, gcc9 -O2 chooses not to inline because it's fairly large. So that would be good for programs that only ever call uuid_unparse(), not a mix of upper/lower.
static inline would make zero difference, unless that keyword also affects GCC's / clang's inlining heuristics as well as telling it that a definition will be visible for any other compilation unit, so the compiler doesn't need to emit a stand-alone definition if it inlines it into all callers. (And nothing takes its address, etc.)