![George Spelvin](/assets/img/avatar_default.png)
Patch series "lib/sort & lib/list_sort: faster and smaller", v2. Because CONFIG_RETPOLINE has made indirect calls much more expensive, I thought I'd try to reduce the number made by the library sort functions. The first three patches apply to lib/sort.c. Patch #1 is a simple optimization. The built-in swap has special cases for aligned 4- and 8-byte objects. But those are almost never used; most calls to sort() work on larger structures, which fall back to the byte-at-a-time loop. This generalizes them to aligned *multiples* of 4 and 8 bytes. (If nothing else, it saves an awful lot of energy by not thrashing the store buffers as much.) Patch #2 grabs a juicy piece of low-hanging fruit. I agree that nice simple solid heapsort is preferable to more complex algorithms (sorry, Andrey), but it's possible to implement heapsort with far fewer comparisons (50% asymptotically, 25-40% reduction for realistic sizes) than the way it's been done up to now. And with some care, the code ends up smaller, as well. This is the "big win" patch. Patch #3 adds the same sort of indirect call bypass that has been added to the net code of late. The great majority of the callers use the builtin swap functions, so replace the indirect call to sort_func with a (highly preditable) series of if() statements. Rather surprisingly, this decreased code size, as the swap functions were inlined and their prologue & epilogue code eliminated. lib/list_sort.c is a bit trickier, as merge sort is already close to optimal, and we don't want to introduce triumphs of theory over practicality like the Ford-Johnson merge-insertion sort. Patch #4, without changing the algorithm, chops 32% off the code size and removes the part[MAX_LIST_LENGTH+1] pointer array (and the corresponding upper limit on efficiently sortable input size). Patch #5 improves the algorithm. The previous code is already optimal for power-of-two (or slightly smaller) size inputs, but when the input size is just over a power of 2, there's a very unbalanced final merge. There are, in the literature, several algorithms which solve this, but they all depend on the "breadth-first" merge order which was replaced by commit835cc0c847
with a more cache-friendly "depth-first" order. Some hard thinking came up with a depth-first algorithm which defers merges as little as possible while avoiding bad merges. This saves 0.2*n compares, averaged over all sizes. The code size increase is minimal (64 bytes on x86-64, reducing the net savings to 26%), but the comments expanded significantly to document the clever algorithm. TESTING NOTES: I have some ugly user-space benchmarking code which I used for testing before moving this code into the kernel. Shout if you want a copy. I'm running this code right now, with CONFIG_TEST_SORT and CONFIG_TEST_LIST_SORT, but I confess I haven't rebooted since the last round of minor edits to quell checkpatch. I figure there will be at least one round of comments and final testing. This patch (of 5): Rather than having special-case swap functions for 4- and 8-byte objects, special-case aligned multiples of 4 or 8 bytes. This speeds up most users of sort() by avoiding fallback to the byte copy loop. Despite whatca96ab859a
("lib/sort: Add 64 bit swap function") claims, very few users of sort() sort pointers (or pointer-sized objects); most sort structures containing at least two words. (E.g. drivers/acpi/fan.c:acpi_fan_get_fps() sorts an array of 40-byte struct acpi_fan_fps.) The functions also got renamed to reflect the fact that they support multiple words. In the great tradition of bikeshedding, the names were by far the most contentious issue during review of this patch series. x86-64 code size 872 -> 886 bytes (+14) With feedback from Andy Shevchenko, Rasmus Villemoes and Geert Uytterhoeven. Link: http://lkml.kernel.org/r/f24f932df3a7fa1973c1084154f1cea596bcf341.1552704200.git.lkml@sdf.org Signed-off-by: George Spelvin <lkml@sdf.org> Acked-by: Andrey Abramov <st5pub@yandex.ru> Acked-by: Rasmus Villemoes <linux@rasmusvillemoes.dk> Reviewed-by: Andy Shevchenko <andriy.shevchenko@linux.intel.com> Cc: Rasmus Villemoes <linux@rasmusvillemoes.dk> Cc: Geert Uytterhoeven <geert@linux-m68k.org> Cc: Daniel Wagner <daniel.wagner@siemens.com> Cc: Don Mullis <don.mullis@gmail.com> Cc: Dave Chinner <dchinner@redhat.com> Signed-off-by: Andrew Morton <akpm@linux-foundation.org> Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
182 lines
5.1 KiB
C
182 lines
5.1 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
/*
|
|
* A fast, small, non-recursive O(nlog n) sort for the Linux kernel
|
|
*
|
|
* Jan 23 2005 Matt Mackall <mpm@selenic.com>
|
|
*/
|
|
|
|
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
|
|
|
|
#include <linux/types.h>
|
|
#include <linux/export.h>
|
|
#include <linux/sort.h>
|
|
|
|
/**
|
|
* is_aligned - is this pointer & size okay for word-wide copying?
|
|
* @base: pointer to data
|
|
* @size: size of each element
|
|
* @align: required aignment (typically 4 or 8)
|
|
*
|
|
* Returns true if elements can be copied using word loads and stores.
|
|
* The size must be a multiple of the alignment, and the base address must
|
|
* be if we do not have CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS.
|
|
*
|
|
* For some reason, gcc doesn't know to optimize "if (a & mask || b & mask)"
|
|
* to "if ((a | b) & mask)", so we do that by hand.
|
|
*/
|
|
__attribute_const__ __always_inline
|
|
static bool is_aligned(const void *base, size_t size, unsigned char align)
|
|
{
|
|
unsigned char lsbits = (unsigned char)size;
|
|
|
|
(void)base;
|
|
#ifndef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
|
|
lsbits |= (unsigned char)(uintptr_t)base;
|
|
#endif
|
|
return (lsbits & (align - 1)) == 0;
|
|
}
|
|
|
|
/**
|
|
* swap_words_32 - swap two elements in 32-bit chunks
|
|
* @a, @b: pointers to the elements
|
|
* @size: element size (must be a multiple of 4)
|
|
*
|
|
* Exchange the two objects in memory. This exploits base+index addressing,
|
|
* which basically all CPUs have, to minimize loop overhead computations.
|
|
*
|
|
* For some reason, on x86 gcc 7.3.0 adds a redundant test of n at the
|
|
* bottom of the loop, even though the zero flag is stil valid from the
|
|
* subtract (since the intervening mov instructions don't alter the flags).
|
|
* Gcc 8.1.0 doesn't have that problem.
|
|
*/
|
|
static void swap_words_32(void *a, void *b, int size)
|
|
{
|
|
size_t n = (unsigned int)size;
|
|
|
|
do {
|
|
u32 t = *(u32 *)(a + (n -= 4));
|
|
*(u32 *)(a + n) = *(u32 *)(b + n);
|
|
*(u32 *)(b + n) = t;
|
|
} while (n);
|
|
}
|
|
|
|
/**
|
|
* swap_words_64 - swap two elements in 64-bit chunks
|
|
* @a, @b: pointers to the elements
|
|
* @size: element size (must be a multiple of 8)
|
|
*
|
|
* Exchange the two objects in memory. This exploits base+index
|
|
* addressing, which basically all CPUs have, to minimize loop overhead
|
|
* computations.
|
|
*
|
|
* We'd like to use 64-bit loads if possible. If they're not, emulating
|
|
* one requires base+index+4 addressing which x86 has but most other
|
|
* processors do not. If CONFIG_64BIT, we definitely have 64-bit loads,
|
|
* but it's possible to have 64-bit loads without 64-bit pointers (e.g.
|
|
* x32 ABI). Are there any cases the kernel needs to worry about?
|
|
*/
|
|
static void swap_words_64(void *a, void *b, int size)
|
|
{
|
|
size_t n = (unsigned int)size;
|
|
|
|
do {
|
|
#ifdef CONFIG_64BIT
|
|
u64 t = *(u64 *)(a + (n -= 8));
|
|
*(u64 *)(a + n) = *(u64 *)(b + n);
|
|
*(u64 *)(b + n) = t;
|
|
#else
|
|
/* Use two 32-bit transfers to avoid base+index+4 addressing */
|
|
u32 t = *(u32 *)(a + (n -= 4));
|
|
*(u32 *)(a + n) = *(u32 *)(b + n);
|
|
*(u32 *)(b + n) = t;
|
|
|
|
t = *(u32 *)(a + (n -= 4));
|
|
*(u32 *)(a + n) = *(u32 *)(b + n);
|
|
*(u32 *)(b + n) = t;
|
|
#endif
|
|
} while (n);
|
|
}
|
|
|
|
/**
|
|
* swap_bytes - swap two elements a byte at a time
|
|
* @a, @b: pointers to the elements
|
|
* @size: element size
|
|
*
|
|
* This is the fallback if alignment doesn't allow using larger chunks.
|
|
*/
|
|
static void swap_bytes(void *a, void *b, int size)
|
|
{
|
|
size_t n = (unsigned int)size;
|
|
|
|
do {
|
|
char t = ((char *)a)[--n];
|
|
((char *)a)[n] = ((char *)b)[n];
|
|
((char *)b)[n] = t;
|
|
} while (n);
|
|
}
|
|
|
|
/**
|
|
* sort - sort an array of elements
|
|
* @base: pointer to data to sort
|
|
* @num: number of elements
|
|
* @size: size of each element
|
|
* @cmp_func: pointer to comparison function
|
|
* @swap_func: pointer to swap function or NULL
|
|
*
|
|
* This function does a heapsort on the given array. You may provide
|
|
* a swap_func function if you need to do something more than a memory
|
|
* copy (e.g. fix up pointers or auxiliary data), but the built-in swap
|
|
* isn't usually a bottleneck.
|
|
*
|
|
* Sorting time is O(n log n) both on average and worst-case. While
|
|
* qsort is about 20% faster on average, it suffers from exploitable
|
|
* O(n*n) worst-case behavior and extra memory requirements that make
|
|
* it less suitable for kernel use.
|
|
*/
|
|
|
|
void sort(void *base, size_t num, size_t size,
|
|
int (*cmp_func)(const void *, const void *),
|
|
void (*swap_func)(void *, void *, int size))
|
|
{
|
|
/* pre-scale counters for performance */
|
|
int i = (num/2 - 1) * size, n = num * size, c, r;
|
|
|
|
if (!swap_func) {
|
|
if (is_aligned(base, size, 8))
|
|
swap_func = swap_words_64;
|
|
else if (is_aligned(base, size, 4))
|
|
swap_func = swap_words_32;
|
|
else
|
|
swap_func = swap_bytes;
|
|
}
|
|
|
|
/* heapify */
|
|
for ( ; i >= 0; i -= size) {
|
|
for (r = i; r * 2 + size < n; r = c) {
|
|
c = r * 2 + size;
|
|
if (c < n - size &&
|
|
cmp_func(base + c, base + c + size) < 0)
|
|
c += size;
|
|
if (cmp_func(base + r, base + c) >= 0)
|
|
break;
|
|
swap_func(base + r, base + c, size);
|
|
}
|
|
}
|
|
|
|
/* sort */
|
|
for (i = n - size; i > 0; i -= size) {
|
|
swap_func(base, base + i, size);
|
|
for (r = 0; r * 2 + size < i; r = c) {
|
|
c = r * 2 + size;
|
|
if (c < i - size &&
|
|
cmp_func(base + c, base + c + size) < 0)
|
|
c += size;
|
|
if (cmp_func(base + r, base + c) >= 0)
|
|
break;
|
|
swap_func(base + r, base + c, size);
|
|
}
|
|
}
|
|
}
|
|
|
|
EXPORT_SYMBOL(sort);
|