github.com/ethereum/go-ethereum@v1.16.1/crypto/secp256k1/libsecp256k1/src/hsort_impl.h (about)

     1  /***********************************************************************
     2   * Copyright (c) 2021 Russell O'Connor, Jonas Nick                     *
     3   * Distributed under the MIT software license, see the accompanying    *
     4   * file COPYING or https://www.opensource.org/licenses/mit-license.php.*
     5   ***********************************************************************/
     6  
     7  #ifndef SECP256K1_HSORT_IMPL_H
     8  #define SECP256K1_HSORT_IMPL_H
     9  
    10  #include "hsort.h"
    11  
    12  /* An array is a heap when, for all non-zero indexes i, the element at index i
    13   * compares as less than or equal to the element at index parent(i) = (i-1)/2.
    14   */
    15  
    16  static SECP256K1_INLINE size_t secp256k1_heap_child1(size_t i) {
    17      VERIFY_CHECK(i <= (SIZE_MAX - 1)/2);
    18      return 2*i + 1;
    19  }
    20  
    21  static SECP256K1_INLINE size_t secp256k1_heap_child2(size_t i) {
    22      VERIFY_CHECK(i <= SIZE_MAX/2 - 1);
    23      return secp256k1_heap_child1(i)+1;
    24  }
    25  
    26  static SECP256K1_INLINE void secp256k1_heap_swap64(unsigned char *a, unsigned char *b, size_t len) {
    27      unsigned char tmp[64];
    28      VERIFY_CHECK(len <= 64);
    29      memcpy(tmp, a, len);
    30      memmove(a, b, len);
    31      memcpy(b, tmp, len);
    32  }
    33  
    34  static SECP256K1_INLINE void secp256k1_heap_swap(unsigned char *arr, size_t i, size_t j, size_t stride) {
    35      unsigned char *a = arr + i*stride;
    36      unsigned char *b = arr + j*stride;
    37      size_t len = stride;
    38      while (64 < len) {
    39          secp256k1_heap_swap64(a + (len - 64), b + (len - 64), 64);
    40          len -= 64;
    41      }
    42      secp256k1_heap_swap64(a, b, len);
    43  }
    44  
    45  /* This function accepts an array arr containing heap_size elements, each of
    46   * size stride. The elements in the array at indices >i satisfy the max-heap
    47   * property, i.e., for any element at index j (where j > i), all of its children
    48   * are smaller than the element itself. The purpose of the function is to update
    49   * the array so that all elements at indices >=i satisfy the max-heap
    50   * property. */
    51  static SECP256K1_INLINE void secp256k1_heap_down(unsigned char *arr, size_t i, size_t heap_size, size_t stride,
    52                              int (*cmp)(const void *, const void *, void *), void *cmp_data) {
    53      while (i < heap_size/2) {
    54          VERIFY_CHECK(i <= SIZE_MAX/2 - 1);
    55          /* Proof:
    56           * i < heap_size/2
    57           * i + 1 <= heap_size/2
    58           * 2*i + 2 <= heap_size <= SIZE_MAX
    59           * 2*i <= SIZE_MAX - 2
    60           */
    61  
    62          VERIFY_CHECK(secp256k1_heap_child1(i) < heap_size);
    63          /* Proof:
    64           * i < heap_size/2
    65           * i + 1 <= heap_size/2
    66           * 2*i + 2 <= heap_size
    67           * 2*i + 1 < heap_size
    68           * child1(i) < heap_size
    69           */
    70  
    71          /* Let [x] be notation for the contents at arr[x*stride].
    72           *
    73           * If [child1(i)] > [i] and [child2(i)] > [i],
    74           *   swap [i] with the larger child to ensure the new parent is larger
    75           *   than both children. When [child1(i)] == [child2(i)], swap [i] with
    76           *   [child2(i)].
    77           * Else if [child1(i)] > [i], swap [i] with [child1(i)].
    78           * Else if [child2(i)] > [i], swap [i] with [child2(i)].
    79           */
    80          if (secp256k1_heap_child2(i) < heap_size
    81                  && 0 <= cmp(arr + secp256k1_heap_child2(i)*stride, arr + secp256k1_heap_child1(i)*stride, cmp_data)) {
    82              if (0 < cmp(arr + secp256k1_heap_child2(i)*stride, arr + i*stride, cmp_data)) {
    83                  secp256k1_heap_swap(arr, i, secp256k1_heap_child2(i), stride);
    84                  i = secp256k1_heap_child2(i);
    85              } else {
    86                  /* At this point we have [child2(i)] >= [child1(i)] and we have
    87                   * [child2(i)] <= [i], and thus [child1(i)] <= [i] which means
    88                   * that the next comparison can be skipped. */
    89                  return;
    90              }
    91          } else if (0 < cmp(arr + secp256k1_heap_child1(i)*stride, arr +         i*stride, cmp_data)) {
    92              secp256k1_heap_swap(arr, i, secp256k1_heap_child1(i), stride);
    93              i = secp256k1_heap_child1(i);
    94          } else {
    95              return;
    96          }
    97      }
    98      /* heap_size/2 <= i
    99       * heap_size/2 < i + 1
   100       * heap_size < 2*i + 2
   101       * heap_size <= 2*i + 1
   102       * heap_size <= child1(i)
   103       * Thus child1(i) and child2(i) are now out of bounds and we are at a leaf.
   104       */
   105  }
   106  
   107  /* In-place heap sort. */
   108  static void secp256k1_hsort(void *ptr, size_t count, size_t size,
   109                              int (*cmp)(const void *, const void *, void *),
   110                              void *cmp_data) {
   111      size_t i;
   112  
   113      for (i = count/2; 0 < i; --i) {
   114          secp256k1_heap_down(ptr, i-1, count, size, cmp, cmp_data);
   115      }
   116      for (i = count; 1 < i; --i) {
   117          /* Extract the largest value from the heap */
   118          secp256k1_heap_swap(ptr, 0, i-1, size);
   119  
   120          /* Repair the heap condition */
   121          secp256k1_heap_down(ptr, 0, i-1, size, cmp, cmp_data);
   122      }
   123  }
   124  
   125  #endif