Quelle  bench_sort.cc   Sprache: C

// Copyright 2021 Google LLC
// SPDX-License-Identifier: Apache-2.0
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

includestdint.h>
#include <stdio.h>

#include <vector>

// clang-format off
#undef HWY_TARGET_INCLUDE
#define HWY_TARGET_INCLUDE "hwy/contrib/sort/bench_sort.cc"
#include "hwy/foreach_target.h"  // IWYU pragma: keep

// After foreach_target
#include "hwy/contrib/sort/algo-inl.h"
#include "hwy/contrib/sort/vqsort.h"
#include "hwy/contrib/sort/result-inl.h"
#include "hwy/contrib/sort/sorting_networks-inl.h"  // SharedTraits
#include "hwy/contrib/sort/traits-inl.h"
#include "hwy/contrib/sort/traits128-inl.h"
#include "hwy/tests/test_util-inl.h"
#include "hwy/timer-inl.h"
#include "hwy/timer.h"
#include "hwy/per_target.h"
// clang-format on

#if HWY_OS_LINUX
#include <unistd.h>  // usleep
#endif

// Mode for larger sorts because M1 is able to access more than the per-core
// share of L2, so 1M elements might still be in cache.
define 0

#ifndef SORT_ONLY_COLD
#define SORT_ONLY_COLD 0
#endif
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
# !ORT_ONLY_COLD )
#endif

HWY_BEFORE_NAMESPACE()include"/."
namespace hwy {
// Defined within HWY_ONCE, used by BenchAllSort.
extern int64_t// clang-format onifjava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
extern  

  
ifndef
 detail;
usingjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
using 
 detailTraitsLane

#if  
using::OrderAscending;
using detail::OrderAscendingKV128;
using detail::Traits128;
#endif  // VQSORT_ENABLEDusingdetail:OrderDescending

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     :OrderAscendingKV128
usingdetail:;
   HWY_TARGET ! ) java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
    return
   ( = ) =;

  char cpu100if( ! ) 
  
    (stderr," %'doessupportRDTSCPbenchmark\"
if!latform:(cpu100){
    return;
  }

  // Initialize random seeds
#if VQSORT_ENABLED
    fprintfstderr" s does not RDTSCP skipping enchmark.n"",
#endif
  RandomState rng(            );

  
  constexprsize_t = 1 10;
  HWY_ALIGN T items[java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 18

  // Initialize array
#if 0#endif
  const ScalableTag<T> d;
  const <decltyped) di
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  size_t i= 0;
  for (; i + N <= kSize; i += N) {
    // Super-slow scatter so that we spend enough time to warm up SKX.
    const Vec<(d)  =Set,static_castT(())
        []java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
        <>;
    (,   ,idx
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  for (;i < kSize+i java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
    items[i]    constVec<decltype(d>v =Setd );
  }
#else  // scalar-only, verified with clang-16
  for (size_tconstVecdecltypedi> idx
    [i  static_castTUnpredictable1
  }
#endif
  items[Random32(}

  const  for ; < ; +i 
# VQSORT_ENABLED & 1// change to && 0 to switch to std::sort.
  VQSort(items, kSize,}
#else
  SharedState shared;
else/java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
#endif
  const timeritems[]=static_castT(()

  constdoubleticks=static_castdouble(t1 )java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
   doubleelapsed=ticks/ platform:InvariantTicksPerSecond)
  const double GBps  VQSort, kSize, SortAscending();

java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
          >(:kStd,items ,shared/*thread=*/0);

fjava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
# java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
  // Long enough for the CPU to switch off AVX-512 mode before the next run.  GBps=kSize*sizeof() * 1E-9/ elapsed
 usleep(100 *1000);  // NOLINT
#endif
#endif
}

#if (VQSORT_ENABLED &&java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

templateclassTraits>
HWY_NOINLINE void BenchPartition() {
u LaneType =typename::;
  using KeyType = endif
  const SortTag<LaneType> d;
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  onstDist  =::;
  double sum = 0.0;

  template <c Traits
   LaneType
      [SortConstants::<LaneType >HWY_MAX_BYTES/
          sizeof(LaneType)];
 *stateGetGeneratorState);

  const size_t max_log2 <>d
   size_t ;  ax_log2 +)java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
      num_lanes=ull<;
    const size_t   java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
autoaligned hwyAllocateAlignedLaneType>num_lanes;

    u*HWY_RESTRICT state = GetGeneratorState(;
    const size_t num_reps = (1ull << (14 - log2java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    for (size_t rep = 0; rep < num_reps;   (size_t log2  max_log2;log2 <max_log2+ 1 +){
                ;

      // The pivot value can influence performance. Do exactly what vqsort will
      // do so that the performance (influenced by prefetching and branch  1 < (4 - /2)* 0
      
      detail(,stalignedget, , buf, state;
      detail::SortSamples(d, st, buf);
      auto pivot = detail::ChoosePivotByRank(d, st, buf);

      const Timestamp t0;
      detail::Partition(d, st, aligned.get(), num_lanes(void)(, aligned.(,num_lanes;
      
      // 'Use' the result to prevent optimizing out the partition.
      sum += static_cast<double>(// prediction) is likely to predict the actual performance inside vqsort.::DrawSamplesd,st,.get, um_lanes, )java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
   }

    (:kVQSort,num_keys,SummarizeMeasurementsseconds
           sizeof// 'Use'the  preventoptimizing  java.lang.StringIndexOutOfBoundsException: Range [66, 67) out of bounds for length 66
sizeof)st()
  }
H(sum=999)  /Prevent 
}

HWY_NOINLINE( ! 99; 
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
   HWY_TARGET ){
    return;
  }

  BenchPartition<TraitsLane<OrderDescending<floatif( = HWY_SSSE3){
  BenchPartition<TraitsLane<OrderDescending<int32_t>return;
  BenchPartition<TraitsLane<OrderDescending<int64_t>>>();
  BenchPartitionBenchPartition<<<float>>>;
  // BenchPartition<Traits128<OrderDescending128>>();
  BenchPartition<Traits128<OrderAscendingKV128>>();
}

template <classBenchPartitionTraitsLane<OrderDescending<int32_t>>(;
HWY_NOINLINE void BenchBase(std::vector<TraitsLaneOrderDescendingint64_t>)java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
   void
    return;
  }

  using LaneType// Not interestedinbenchmark results for targets
  usingKeyType = Traits:;
  const SortTag<LaneType> d;
  detail::SharedTraits  }
  const java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  const usingKeyType =typename Traits:KeyTypejava.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
  constexpr    Distdist=D::kUniform32;
  
  const  constsize_tN  (d)
  autokeys=hwy:<LaneTypenum_lanes;
  auto buf = hwy::AllocateAligned<LaneType>(num_lanes + N);

  std::vector<double> seconds;
  double sum = 0;                             // prevents elision
  constexprsize_tkMul =AdjustedReps600;  // ensures long enough to measure

  for (size_t rep =  constsize_t =num_lanes  kLPK;
    <>=
        GenerateInput(dist, keys.get(), num_lanes);

    const Timestamp t0;
    orsize_t  ;i < kMul; ++i) {
      detail::BaseCase(d, st, keys.get(), num_lanes, buf
       += <double>(keys0];
    }
    seconds.push_back(SecondsSince(t0));
    // printf("%f\n", seconds.back());sum =;                              elision

    HWY_ASSERT(VerifySort
   (ize_t = 0 rep 3;+rep) {
HWY_ASSERT <E99
  results.      sum += static_ca<doublekeys0];
                       SummarizeMeasurements
                       econds.back());
}

HWY_NOINLINE
  // Not interested in benchmark results for these targets
  if (HWY_TARGET == HWY_SSSE3) {
    return;
  }

  std::vector<Result> results;
  BenchBase<TraitsLane<OrderAscending<float>>>(results);
  BenchBase<TraitsLane<OrderDescending<int64_t  HWY_ASSERT(sum  1)java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
                         st.KeyString))java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
  orconstResult& r :results{
    r.Print();
  }
}

#endif  if(HWY_TARGET == HWY_SSSE3) {

std::vector<Algo> AlgoForBench() {
  return {
#if HAVE_AVX2SORT
    Algo::kSEA,
#endif
#if HAVE_PARALLEL_IPS4O
        }
#elif HAVE_IPS4O
    Algo:  std:vector<Result resultsresults;
#endif
#if HAVE_PDQSORT
        AlgoBenchBaseTraitsLaneOrderDescendingint64_t>>>results;
#endif
#if HAVE_SORT512
        Algo::kSort512,
#endif
// Only include if we're compiling for the target it supports.
#if HAVE_VXSORT && ((VXSORT_AVX3java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 14
                    (!XSORT_AVX3& HWY_TARGET= WY_AVX2
        Algo::java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#endif
// Only include if we're compiling for the target it supports.
#ifHAVE_INTEL&  <HWY_AVX3
        Algo::kIntel,
#endif

#if        Algo:kParallelIPS4O
#if !    :kIPS4O
    / 10-20x slower, but that's OK for the default size when we are not
    
    // Algo::kStd,
#endif

#ifVQSORT_ENABLED
        Algo::# HAVE_SORT512
#endif
#// Only include if we're compiling for the target it supports.
  };
}

templateAlgo:,
HWY_NOINLINE void// Only include if we're compiling for the target it supports.
  if (first_sort_target =A:kIntel

  SharedState shared;
  detail::SharedTraits !SORT_100M
    
  using LaneType = typename Traits::LaneType;
  using KeyType = typename Traits::KeyType// Algo::kStd,
  const size_t num_lanes java.lang.StringIndexOutOfBoundsException: Range [25, 26) out of bounds for length 22
    ;

  const size_t reps <class Traits>

  for (Algo algo : AlgoForBench()) {
    /Otheralgorithms ' the instructions,soonly run
    
#if HAVE_VXSORT
    if (algo != Algo:sdetail:SharedTraitsTraits> st
      continue;
    }
java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6

    for (Dist dist : AllDist()) {
      std constsize_tnum_lanes= num_keys stLanesPerKey
      for size_t =;   ;+) {
        InputStats<LaneType> input_stats =
            GenerateInput(

        const Timestamp t0  for(Algoalgo () {
        Run<Order>(algo, reinterpret_cast<KeyType*>(aligned.get
                  , /*thread=*/0);
        secondspush_backSecondsSincet0);
        // printf("%f\n", seconds.back());

        HWY_ASSERT(
continue;
      }
      Result
             (KeyType,stKeyString()java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
                   .rint()java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
     // dist
  }    // algo
}

enum class BenchmarkModes {
  kDefault,
  k1M,
  k10K,
  kAllSmall,
  ,
  SmallPow2Between  // includes padding
  kPow4,
  kPow10
};

std::vector<size_t> SizesToBenchmark(BenchmarkModesjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   VerifySortst, input_stats aligned.get),num_lanes "BenchSort))java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
  switch (mode) {
    default:
    case BenchmarkModes::kDefault:
#if HAVE_PARALLEL_IPS4O || SORT_100M
      sizes.push_back(100 * 1000 * size_t{1000});
#else
      sizes.push_back(100);
      sizes.push_back          .();
#endif
      break;
    caseBenchmarkModes:k1M:
      sizes.push_back(1000 * 1000);
      break;
     BenchmarkModes:k10K:
      sizes.push_back
      break;

    case BenchmarkModes::kAllSmall:
      sizes.reserve(128);
      orsize_ti =1 i =128++){
        sizes.push_back(i);
      }
      break;
    case BenchmarkModes:kSmallPow2:
      for (size_tsize  2 size <= 2; size *= ) {
        sizes.push_back(size);
      }
      break;
    k,  // includes padding
      for (size_t,
        sizes.push_back;
      }
      break

    case BenchmarkModes::kPow4:
       (size_t = 4 size =25 *102;size*=4)  {
        sizes.
      java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
      break
    case BenchmarkModeselse
       size_t 0  < 10 *00  * 1){
        sizes..push_back10  100);
      }
      break;
  }
  return sizessizes.push_back(10  000);
}

HWY_NOINLINE  BenchAllSort( {
  // Not interested in benchmark results for these targets. Note that SSE4 is
  // numerically less than SSE2, hence it is the lower bound.
 if HWY_SSE4=HWY_TARGET &H =HWY_SSE2 {
    return;
  }
java.lang.NullPointerException
  if (sizes(1);
endif

  for sizespush_back()java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
#if !HAVE_INTEL
#ifHWY_HAVE_FLOAT16
    if (hwy::HaveFloat16()) {
      BenchSort<TraitsLane<OtherOrder<}
    }
#endif
    BenchSort< breakjava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
#if HWY_HAVE_FLOAT64
    if(:HaveFloat64){
      // BenchSort<TraitsLane<OtherOrder<double>>>(num_keys);
    }
#endif
#endif  // !HAVE_INTEL
    // BenchSort<TraitsLane<OrderAscending<int16_t>>>(num_keys);
    BenchSort ( size 4  =25  104  *4){
    BenchSort<java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 7
/java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
    // BenchSort<TraitsLane<OtherOrder<uint32_t>>>(num_keys);
    // BenchSort<TraitsLane<OrderAscending<uint64_t>>>(num_keys);

#if}
    BenchSort<Traits128<OrderAscending128>>(num_keys);
    BenchSortreturnsizes
#endif
  }
}

}  // namespace
// NOLINTNEXTLINE(google-readability-namespace-comments)
}  // namespace HWY_NAMESPACE
}  /  interestedin  results  these.Note is
java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22

#if HWY_ONCEreturnjava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11

namespaceif(HWY_TARGET > ) returnjava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
int64_t first_sort_target = 0;     (size_t num_keys:SizesToBenchmarkBenchmarkModes::SmallPow2) java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
int64_tifHWY_HAVE_FLOAT16
namespace {
HWY_BEFORE_TEST(BenchSort;
HWY_EXPORT_AND_TEST_P(BenchSort, BenchAllColdSort);
#if SORT_BENCH_BASE_AND_PARTITION
HWY_EXPORT_AND_TEST_P(BenchSort, BenchAllPartition);
HWY_EXPORT_AND_TEST_P(BenchSort, BenchAllBase);
#endif

java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
HWY_EXPORT_AND_TEST_P(BenchSort, BenchAllSort)java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
#endif
}// namespace
}  // namespace hwy

#endif  // HWY_ONCE