Skip to content

Commit

Permalink
Merge pull request godotengine#88551 from AThousandShips/helpers_fix
Browse files Browse the repository at this point in the history 
[Core] Upgrade some array helper classes to 64 bits
  • Loading branch information
@akien-mga
akien-mga committed Feb 19, 2024
2 parents 37cca2b + 06f1b11 commit 371597a
Show file tree
Hide file tree
Showing 2 changed files with 41 additions and 41 deletions.
10 changes: 5 additions & 5 deletions core/templates/search_array.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -38,12 +38,12 @@ class SearchArray {
public:
Comparator compare;

inline int bisect(const T *p_array, int p_len, const T &p_value, bool p_before) const {
int lo = 0;
int hi = p_len;
inline int64_t bisect(const T *p_array, int64_t p_len, const T &p_value, bool p_before) const {
int64_t lo = 0;
int64_t hi = p_len;
if (p_before) {
while (lo < hi) {
const int mid = (lo + hi) / 2;
const int64_t mid = (lo + hi) / 2;
if (compare(p_array[mid], p_value)) {
lo = mid + 1;
} else {
Expand All @@ -52,7 +52,7 @@ class SearchArray {
}
} else {
while (lo < hi) {
const int mid = (lo + hi) / 2;
const int64_t mid = (lo + hi) / 2;
if (compare(p_value, p_array[mid])) {
hi = mid;
} else {
Expand Down
72 changes: 36 additions & 36 deletions core/templates/sort_array.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -78,8 +78,8 @@ class SortArray {
}
}

inline int bitlog(int n) const {
int k;
inline int64_t bitlog(int64_t n) const {
int64_t k;
for (k = 0; n != 1; n >>= 1) {
++k;
}
Expand All @@ -88,8 +88,8 @@ class SortArray {

/* Heap / Heapsort functions */

inline void push_heap(int p_first, int p_hole_idx, int p_top_index, T p_value, T *p_array) const {
int parent = (p_hole_idx - 1) / 2;
inline void push_heap(int64_t p_first, int64_t p_hole_idx, int64_t p_top_index, T p_value, T *p_array) const {
int64_t parent = (p_hole_idx - 1) / 2;
while (p_hole_idx > p_top_index && compare(p_array[p_first + parent], p_value)) {
p_array[p_first + p_hole_idx] = p_array[p_first + parent];
p_hole_idx = parent;
Expand All @@ -98,17 +98,17 @@ class SortArray {
p_array[p_first + p_hole_idx] = p_value;
}

inline void pop_heap(int p_first, int p_last, int p_result, T p_value, T *p_array) const {
inline void pop_heap(int64_t p_first, int64_t p_last, int64_t p_result, T p_value, T *p_array) const {
p_array[p_result] = p_array[p_first];
adjust_heap(p_first, 0, p_last - p_first, p_value, p_array);
}
inline void pop_heap(int p_first, int p_last, T *p_array) const {
inline void pop_heap(int64_t p_first, int64_t p_last, T *p_array) const {
pop_heap(p_first, p_last - 1, p_last - 1, p_array[p_last - 1], p_array);
}

inline void adjust_heap(int p_first, int p_hole_idx, int p_len, T p_value, T *p_array) const {
int top_index = p_hole_idx;
int second_child = 2 * p_hole_idx + 2;
inline void adjust_heap(int64_t p_first, int64_t p_hole_idx, int64_t p_len, T p_value, T *p_array) const {
int64_t top_index = p_hole_idx;
int64_t second_child = 2 * p_hole_idx + 2;

while (second_child < p_len) {
if (compare(p_array[p_first + second_child], p_array[p_first + (second_child - 1)])) {
Expand All @@ -127,18 +127,18 @@ class SortArray {
push_heap(p_first, p_hole_idx, top_index, p_value, p_array);
}

inline void sort_heap(int p_first, int p_last, T *p_array) const {
inline void sort_heap(int64_t p_first, int64_t p_last, T *p_array) const {
while (p_last - p_first > 1) {
pop_heap(p_first, p_last--, p_array);
}
}

inline void make_heap(int p_first, int p_last, T *p_array) const {
inline void make_heap(int64_t p_first, int64_t p_last, T *p_array) const {
if (p_last - p_first < 2) {
return;
}
int len = p_last - p_first;
int parent = (len - 2) / 2;
int64_t len = p_last - p_first;
int64_t parent = (len - 2) / 2;

while (true) {
adjust_heap(p_first, parent, len, p_array[p_first + parent], p_array);
Expand All @@ -149,28 +149,28 @@ class SortArray {
}
}

inline void partial_sort(int p_first, int p_last, int p_middle, T *p_array) const {
inline void partial_sort(int64_t p_first, int64_t p_last, int64_t p_middle, T *p_array) const {
make_heap(p_first, p_middle, p_array);
for (int i = p_middle; i < p_last; i++) {
for (int64_t i = p_middle; i < p_last; i++) {
if (compare(p_array[i], p_array[p_first])) {
pop_heap(p_first, p_middle, i, p_array[i], p_array);
}
}
sort_heap(p_first, p_middle, p_array);
}

inline void partial_select(int p_first, int p_last, int p_middle, T *p_array) const {
inline void partial_select(int64_t p_first, int64_t p_last, int64_t p_middle, T *p_array) const {
make_heap(p_first, p_middle, p_array);
for (int i = p_middle; i < p_last; i++) {
for (int64_t i = p_middle; i < p_last; i++) {
if (compare(p_array[i], p_array[p_first])) {
pop_heap(p_first, p_middle, i, p_array[i], p_array);
}
}
}

inline int partitioner(int p_first, int p_last, T p_pivot, T *p_array) const {
const int unmodified_first = p_first;
const int unmodified_last = p_last;
inline int64_t partitioner(int64_t p_first, int64_t p_last, T p_pivot, T *p_array) const {
const int64_t unmodified_first = p_first;
const int64_t unmodified_last = p_last;

while (true) {
while (compare(p_array[p_first], p_pivot)) {
Expand All @@ -196,7 +196,7 @@ class SortArray {
}
}

inline void introsort(int p_first, int p_last, T *p_array, int p_max_depth) const {
inline void introsort(int64_t p_first, int64_t p_last, T *p_array, int64_t p_max_depth) const {
while (p_last - p_first > INTROSORT_THRESHOLD) {
if (p_max_depth == 0) {
partial_sort(p_first, p_last, p_last, p_array);
Expand All @@ -205,7 +205,7 @@ class SortArray {

p_max_depth--;

int cut = partitioner(
int64_t cut = partitioner(
p_first,
p_last,
median_of_3(
Expand All @@ -219,7 +219,7 @@ class SortArray {
}
}

inline void introselect(int p_first, int p_nth, int p_last, T *p_array, int p_max_depth) const {
inline void introselect(int64_t p_first, int64_t p_nth, int64_t p_last, T *p_array, int64_t p_max_depth) const {
while (p_last - p_first > 3) {
if (p_max_depth == 0) {
partial_select(p_first, p_nth + 1, p_last, p_array);
Expand All @@ -229,7 +229,7 @@ class SortArray {

p_max_depth--;

int cut = partitioner(
int64_t cut = partitioner(
p_first,
p_last,
median_of_3(
Expand All @@ -248,8 +248,8 @@ class SortArray {
insertion_sort(p_first, p_last, p_array);
}

inline void unguarded_linear_insert(int p_last, T p_value, T *p_array) const {
int next = p_last - 1;
inline void unguarded_linear_insert(int64_t p_last, T p_value, T *p_array) const {
int64_t next = p_last - 1;
while (compare(p_value, p_array[next])) {
if (Validate) {
ERR_BAD_COMPARE(next == 0);
Expand All @@ -261,10 +261,10 @@ class SortArray {
p_array[p_last] = p_value;
}

inline void linear_insert(int p_first, int p_last, T *p_array) const {
inline void linear_insert(int64_t p_first, int64_t p_last, T *p_array) const {
T val = p_array[p_last];
if (compare(val, p_array[p_first])) {
for (int i = p_last; i > p_first; i--) {
for (int64_t i = p_last; i > p_first; i--) {
p_array[i] = p_array[i - 1];
}

Expand All @@ -274,22 +274,22 @@ class SortArray {
}
}

inline void insertion_sort(int p_first, int p_last, T *p_array) const {
inline void insertion_sort(int64_t p_first, int64_t p_last, T *p_array) const {
if (p_first == p_last) {
return;
}
for (int i = p_first + 1; i != p_last; i++) {
for (int64_t i = p_first + 1; i != p_last; i++) {
linear_insert(p_first, i, p_array);
}
}

inline void unguarded_insertion_sort(int p_first, int p_last, T *p_array) const {
for (int i = p_first; i != p_last; i++) {
inline void unguarded_insertion_sort(int64_t p_first, int64_t p_last, T *p_array) const {
for (int64_t i = p_first; i != p_last; i++) {
unguarded_linear_insert(i, p_array[i], p_array);
}
}

inline void final_insertion_sort(int p_first, int p_last, T *p_array) const {
inline void final_insertion_sort(int64_t p_first, int64_t p_last, T *p_array) const {
if (p_last - p_first > INTROSORT_THRESHOLD) {
insertion_sort(p_first, p_first + INTROSORT_THRESHOLD, p_array);
unguarded_insertion_sort(p_first + INTROSORT_THRESHOLD, p_last, p_array);
Expand All @@ -298,18 +298,18 @@ class SortArray {
}
}

inline void sort_range(int p_first, int p_last, T *p_array) const {
inline void sort_range(int64_t p_first, int64_t p_last, T *p_array) const {
if (p_first != p_last) {
introsort(p_first, p_last, p_array, bitlog(p_last - p_first) * 2);
final_insertion_sort(p_first, p_last, p_array);
}
}

inline void sort(T *p_array, int p_len) const {
inline void sort(T *p_array, int64_t p_len) const {
sort_range(0, p_len, p_array);
}

inline void nth_element(int p_first, int p_last, int p_nth, T *p_array) const {
inline void nth_element(int64_t p_first, int64_t p_last, int64_t p_nth, T *p_array) const {
if (p_first == p_last || p_nth == p_last) {
return;
}
Expand Down

0 comments on commit 371597a

Please sign in to comment.