152 changes: 152 additions & 0 deletions libc/src/stdlib/qsort_util.h
View file
Original file line number Diff line number Diff line change
@@ -0,0 +1,152 @@
//===-- Implementation header for qsort utilities ---------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

#ifndef LLVM_LIBC_SRC_STDLIB_QSORT_UTIL_H
#define LLVM_LIBC_SRC_STDLIB_QSORT_UTIL_H

#include "src/__support/macros/attributes.h"
#include <stdint.h>
#include <stdlib.h>

namespace __llvm_libc::internal {

// A simple quicksort implementation using the Hoare partition scheme.

using Compare = int(const void *, const void *);
using CompareWithState = int(const void *, const void *, void *);

enum class CompType { COMPARE, COMPARE_WITH_STATE };

struct Comparator {
union {
Compare *comp_func;
CompareWithState *comp_func_r;
};
const CompType comp_type;

void *arg;

Comparator(Compare *func)
: comp_func(func), comp_type(CompType::COMPARE), arg(nullptr) {}

Comparator(CompareWithState *func, void *arg_val)
: comp_func_r(func), comp_type(CompType::COMPARE_WITH_STATE),
arg(arg_val) {}

#if defined(__clang__)
// Recent upstream changes to -fsanitize=function find more instances of
// function type mismatches. One case is with the comparator passed to this
// class. Libraries will tend to pass comparators that take pointers to
// varying types while this comparator expects to accept const void pointers.
// Ideally those tools would pass a function that strictly accepts const
// void*s to avoid UB, or would use qsort_r to pass their own comparator.
[[clang::no_sanitize("function")]]
#endif
int comp_vals(const void *a, const void *b) const {
if (comp_type == CompType::COMPARE) {
return comp_func(a, b);
} else {
return comp_func_r(a, b, arg);
}
}
};

class Array {
uint8_t *array;
size_t array_size;
size_t elem_size;
Comparator compare;

public:
Array(uint8_t *a, size_t s, size_t e, Comparator c)
: array(a), array_size(s), elem_size(e), compare(c) {}

uint8_t *get(size_t i) const { return array + i * elem_size; }

void swap(size_t i, size_t j) const {
uint8_t *elem_i = get(i);
uint8_t *elem_j = get(j);
for (size_t b = 0; b < elem_size; ++b) {
uint8_t temp = elem_i[b];
elem_i[b] = elem_j[b];
elem_j[b] = temp;
}
}

int elem_compare(size_t i, const uint8_t *other) const {
// An element must compare equal to itself so we don't need to consult the
// user provided comparator.
if (get(i) == other)
return 0;
return compare.comp_vals(get(i), other);
}

size_t size() const { return array_size; }

// Make an Array starting at index |i| and size |s|.
Array make_array(size_t i, size_t s) const {
return Array(get(i), s, elem_size, compare);
}
};

static size_t partition(const Array &array) {
const size_t array_size = array.size();
size_t pivot_index = array_size / 2;
uint8_t *pivot = array.get(pivot_index);
size_t i = 0;
size_t j = array_size - 1;

while (true) {
int compare_i, compare_j;

while ((compare_i = array.elem_compare(i, pivot)) < 0)
++i;
while ((compare_j = array.elem_compare(j, pivot)) > 0)
--j;

// At some point i will crossover j so we will definitely break out of
// this while loop.
if (i >= j)
return j + 1;

array.swap(i, j);

// The pivot itself might have got swapped so we will update the pivot.
if (i == pivot_index) {
pivot = array.get(j);
pivot_index = j;
} else if (j == pivot_index) {
pivot = array.get(i);
pivot_index = i;
}

if (compare_i == 0 && compare_j == 0) {
// If we do not move the pointers, we will end up with an
// infinite loop as i and j will be stuck without advancing.
++i;
--j;
}
}
}

LIBC_INLINE void quicksort(const Array &array) {
const size_t array_size = array.size();
if (array_size <= 1)
return;
size_t split_index = partition(array);
if (array_size <= 2) {
// The partition operation sorts the two element array.
return;
}
quicksort(array.make_array(0, split_index));
quicksort(array.make_array(split_index, array.size() - split_index));
}

} // namespace __llvm_libc::internal

#endif // LLVM_LIBC_SRC_STDLIB_QSORT_UTIL_H
12 changes: 12 additions & 0 deletions libc/test/src/stdlib/CMakeLists.txt
View file
Original file line number Diff line number Diff line change
Expand Up @@ -259,6 +259,18 @@ add_libc_test(
libc.src.stdlib.qsort
)


add_libc_test(
qsort_r_test
SUITE
libc-stdlib-tests
SRCS
qsort_r_test.cpp
DEPENDS
libc.include.stdlib
libc.src.stdlib.qsort_r
)

add_libc_test(
rand_test
SUITE
Expand Down
144 changes: 144 additions & 0 deletions libc/test/src/stdlib/qsort_r_test.cpp
View file
Original file line number Diff line number Diff line change
@@ -0,0 +1,144 @@
//===-- Unittests for qsort_r ---------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

#include "src/stdlib/qsort_r.h"

#include "test/UnitTest/Test.h"

#include <stdlib.h>

static int int_compare_count(const void *l, const void *r, void *count_arg) {
int li = *reinterpret_cast<const int *>(l);
int ri = *reinterpret_cast<const int *>(r);
size_t *count = reinterpret_cast<size_t *>(count_arg);
*count = *count + 1;
if (li == ri)
return 0;
else if (li > ri)
return 1;
else
return -1;
}

TEST(LlvmLibcQsortRTest, SortedArray) {
int array[25] = {10, 23, 33, 35, 55, 70, 71, 100, 110,
123, 133, 135, 155, 170, 171, 1100, 1110, 1123,
1133, 1135, 1155, 1170, 1171, 11100, 12310};
constexpr size_t ARRAY_SIZE = sizeof(array) / sizeof(int);

size_t count = 0;

__llvm_libc::qsort_r(array, ARRAY_SIZE, sizeof(int), int_compare_count,
&count);

ASSERT_LE(array[0], 10);
ASSERT_LE(array[1], 23);
ASSERT_LE(array[2], 33);
ASSERT_LE(array[3], 35);
ASSERT_LE(array[4], 55);
ASSERT_LE(array[5], 70);
ASSERT_LE(array[6], 71);
ASSERT_LE(array[7], 100);
ASSERT_LE(array[8], 110);
ASSERT_LE(array[9], 123);
ASSERT_LE(array[10], 133);
ASSERT_LE(array[11], 135);
ASSERT_LE(array[12], 155);
ASSERT_LE(array[13], 170);
ASSERT_LE(array[14], 171);
ASSERT_LE(array[15], 1100);
ASSERT_LE(array[16], 1110);
ASSERT_LE(array[17], 1123);
ASSERT_LE(array[18], 1133);
ASSERT_LE(array[19], 1135);
ASSERT_LE(array[20], 1155);
ASSERT_LE(array[21], 1170);
ASSERT_LE(array[22], 1171);
ASSERT_LE(array[23], 11100);
ASSERT_LE(array[24], 12310);

// This is a sorted list, but there still have to have been at least N
// comparisons made.
ASSERT_GE(count, ARRAY_SIZE);
}

TEST(LlvmLibcQsortRTest, ReverseSortedArray) {
int array[25] = {25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13,
12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1};
constexpr size_t ARRAY_SIZE = sizeof(array) / sizeof(int);

size_t count = 0;

__llvm_libc::qsort_r(array, ARRAY_SIZE, sizeof(int), int_compare_count,
&count);

for (int i = 0; i < int(ARRAY_SIZE - 1); ++i)
ASSERT_LE(array[i], i + 1);

ASSERT_GE(count, ARRAY_SIZE);
}

// The following test is intended to mimic the CPP library pattern of having a
// comparison function that takes a specific type, which is passed to a library
// that then needs to sort an array of that type. The library can't safely pass
// the comparison function to qsort because a function that takes const T*
// being cast to a function that takes const void* is undefined behavior. The
// safer pattern is to pass a type erased comparator that calls into the typed
// comparator to qsort_r.

struct PriorityVal {
int priority;
int size;
};

static int compare_priority_val(const PriorityVal *l, const PriorityVal *r) {
// Subtracting the priorities is unsafe, but it's fine for this test.
int priority_diff = l->priority - r->priority;
if (priority_diff != 0) {
return priority_diff;
}
if (l->size == r->size) {
return 0;
} else if (l->size > r->size) {
return 1;
} else {
return -1;
}
}

template <typename T>
static int type_erased_comp(const void *l, const void *r,
void *erased_func_ptr) {
typedef int (*TypedComp)(const T *, const T *);
TypedComp typed_func_ptr = reinterpret_cast<TypedComp>(erased_func_ptr);
const T *lt = reinterpret_cast<const T *>(l);
const T *rt = reinterpret_cast<const T *>(r);
return typed_func_ptr(lt, rt);
}

TEST(LlvmLibcQsortRTest, SafeTypeErasure) {
PriorityVal array[5] = {
{10, 3}, {1, 10}, {-1, 100}, {10, 0}, {3, 3},
};
constexpr size_t ARRAY_SIZE = sizeof(array) / sizeof(PriorityVal);

__llvm_libc::qsort_r(array, ARRAY_SIZE, sizeof(PriorityVal),
type_erased_comp<PriorityVal>,
reinterpret_cast<void *>(compare_priority_val));

EXPECT_EQ(array[0].priority, -1);
EXPECT_EQ(array[0].size, 100);
EXPECT_EQ(array[1].priority, 1);
EXPECT_EQ(array[1].size, 10);
EXPECT_EQ(array[2].priority, 3);
EXPECT_EQ(array[2].size, 3);
EXPECT_EQ(array[3].priority, 10);
EXPECT_EQ(array[3].size, 0);
EXPECT_EQ(array[4].priority, 10);
EXPECT_EQ(array[4].size, 3);
}
20 changes: 20 additions & 0 deletions utils/bazel/llvm-project-overlay/libc/BUILD.bazel
View file
Original file line number Diff line number Diff line change
Expand Up @@ -1859,12 +1859,32 @@ libc_function(
],
)

libc_support_library(
name = "qsort_util",
hdrs = ["src/stdlib/qsort_util.h"],
deps = [
":__support_common",
":__support_macros_attributes",
],
)

libc_function(
name = "qsort",
srcs = ["src/stdlib/qsort.cpp"],
hdrs = ["src/stdlib/qsort.h"],
deps = [
":__support_common",
":qsort_util",
],
)

libc_function(
name = "qsort_r",
srcs = ["src/stdlib/qsort_r.cpp"],
hdrs = ["src/stdlib/qsort_r.h"],
deps = [
":__support_common",
":qsort_util",
],
)

Expand Down
8 changes: 8 additions & 0 deletions utils/bazel/llvm-project-overlay/libc/test/src/stdlib/BUILD.bazel
View file
Original file line number Diff line number Diff line change
Expand Up @@ -138,6 +138,14 @@ libc_test(
],
)

libc_test(
name = "qsort_r_test",
srcs = ["qsort_r_test.cpp"],
libc_function_deps = [
"//libc:qsort_r",
],
)

cc_library(
name = "strtol_test_helper",
hdrs = ["StrtolTest.h"],
Expand Down