libcxx: Rename .hpp files in libcxx/benchmarks to .h

[thakis]

Summary

LLVM uses .h as its extension for header files.

libcxx/benchmarks/ContainerBenchmarks.h

 // -*- 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 BENCHMARK_CONTAINER_BENCHMARKS_HPP
-#define BENCHMARK_CONTAINER_BENCHMARKS_HPP
+#ifndef BENCHMARK_CONTAINER_BENCHMARKS_H
+#define BENCHMARK_CONTAINER_BENCHMARKS_H
 
 #include <cassert>
 
-#include "Utilities.hpp"
+#include "Utilities.h"
 #include "benchmark/benchmark.h"
 
 namespace ContainerBenchmarks {
 
 template <class Container>
 void BM_ConstructSize(benchmark::State& st, Container) {
   auto size = st.range(0);
   for (auto _ : st) {
while (st.KeepRunning()) {
             benchmark::DoNotOptimize(&(*c.find(*it)));
         }
         benchmark::ClobberMemory();
     }
 }
 
 } // end namespace ContainerBenchmarks
 
-#endif // BENCHMARK_CONTAINER_BENCHMARKS_HPP
+#endif // BENCHMARK_CONTAINER_BENCHMARKS_H

libcxx/benchmarks/GenerateInput.h

-#ifndef BENCHMARK_GENERATE_INPUT_HPP
-#define BENCHMARK_GENERATE_INPUT_HPP
+#ifndef BENCHMARK_GENERATE_INPUT_H
+#define BENCHMARK_GENERATE_INPUT_H
 
 #include <algorithm>
 #include <random>
 #include <vector>
 #include <string>
 #include <climits>
 #include <cstddef>
 
inline std::vector<const char*> getRandomCStringInputs(size_t N) {
     static std::vector<std::string> inputs = getRandomStringInputs(N);
     std::vector<const char*> cinputs;
     for (auto const& str : inputs)
         cinputs.push_back(str.c_str());
     return cinputs;
 }
 
 
-#endif // BENCHMARK_GENERATE_INPUT_HPP
+#endif // BENCHMARK_GENERATE_INPUT_H

libcxx/benchmarks/Utilities.h

 // -*- 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 BENCHMARK_UTILITIES_HPP
-#define BENCHMARK_UTILITIES_HPP
+#ifndef BENCHMARK_UTILITIES_H
+#define BENCHMARK_UTILITIES_H
 
 #include <cassert>
 #include <type_traits>
 
 #include "benchmark/benchmark.h"
 
 namespace UtilitiesInternal {
   template <class Container>
   auto HaveDataImpl(int) -> decltype((std::declval<Container&>().data(), std::true_type{}));
   template <class Container>
   auto HaveDataImpl(long) -> std::false_type;
   template <class T>
   using HasData = decltype(HaveDataImpl<T>(0));
 } // namespace UtilitiesInternal
 
 template <class Container, std::enable_if_t<UtilitiesInternal::HasData<Container>::value>* = nullptr>
 void DoNotOptimizeData(Container &c) { benchmark::DoNotOptimize(c.data()); }
 template <class Container, std::enable_if_t<!UtilitiesInternal::HasData<Container>::value>* = nullptr>
 void DoNotOptimizeData(Container &c) { benchmark::DoNotOptimize(&c); }
 
 
-#endif // BENCHMARK_UTILITIES_HPP
+#endif // BENCHMARK_UTILITIES_H

libcxx/benchmarks/algorithms.bench.cpp

 
 #include <algorithm>
 #include <cstdint>
 #include <map>
 #include <random>
 #include <string>
 #include <utility>
 #include <vector>
 
-#include "CartesianBenchmarks.hpp"
-#include "GenerateInput.hpp"
+#include "CartesianBenchmarks.h"
+#include "GenerateInput.h"
 #include "benchmark/benchmark.h"
 #include "test_macros.h"
 
 namespace {
 
 enum class ValueType { Uint32, String };
 struct AllValueTypes : EnumValuesAsTuple<AllValueTypes, ValueType, 2> {
   static constexpr const char* Names[] = {"uint32", "string"};

libcxx/benchmarks/algorithms.partition_point.bench.cpp

 #include <array>
 #include <algorithm>
 #include <cassert>
 #include <cstdint>
 #include <tuple>
 #include <vector>
 
 #include "benchmark/benchmark.h"
 
-#include "CartesianBenchmarks.hpp"
-#include "GenerateInput.hpp"
+#include "CartesianBenchmarks.h"
+#include "GenerateInput.h"
 
 namespace {
 
 template <typename I, typename N>
 std::array<I, 10> every_10th_percentile_N(I first, N n) {
   N step = n / 10;
   std::array<I, 10> res;
 

libcxx/benchmarks/deque.bench.cpp

 // -*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #include <deque>
 
 #include "benchmark/benchmark.h"
 
-#include "ContainerBenchmarks.hpp"
-#include "GenerateInput.hpp"
+#include "ContainerBenchmarks.h"
+#include "GenerateInput.h"
 
 using namespace ContainerBenchmarks;
 
 constexpr std::size_t TestNumInputs = 1024;
 
 BENCHMARK_CAPTURE(BM_ConstructSize,
     deque_byte,
     std::deque<unsigned char>{})->Arg(5140480);

libcxx/benchmarks/filesystem.bench.cpp

 #include "benchmark/benchmark.h"
-#include "GenerateInput.hpp"
+#include "GenerateInput.h"
 #include "test_iterators.h"
 #include "filesystem_include.h"
 
 static const size_t TestNumInputs = 1024;
 
 
 template <class GenInputs>
 void BM_PathConstructString(benchmark::State &st, GenInputs gen) {

libcxx/benchmarks/function.bench.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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 <cstdint>
 #include <functional>
 #include <memory>
 #include <string>
 
-#include "CartesianBenchmarks.hpp"
+#include "CartesianBenchmarks.h"
 #include "benchmark/benchmark.h"
 #include "test_macros.h"
 
 namespace {
 
 enum class FunctionType {
   Null,
   FunctionPointer,

libcxx/benchmarks/ordered_set.bench.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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 <algorithm>
 #include <cstdint>
 #include <memory>
 #include <random>
 #include <set>
 #include <string>
 #include <vector>
 
-#include "CartesianBenchmarks.hpp"
+#include "CartesianBenchmarks.h"
 #include "benchmark/benchmark.h"
 #include "test_macros.h"
 
 namespace {
 
 enum class HitType { Hit, Miss };
 
 struct AllHitTypes : EnumValuesAsTuple<AllHitTypes, HitType, 2> {

libcxx/benchmarks/string.bench.cpp

 
 #include <cstdint>
 #include <new>
 #include <vector>
 
-#include "CartesianBenchmarks.hpp"
-#include "GenerateInput.hpp"
+#include "CartesianBenchmarks.h"
+#include "GenerateInput.h"
 #include "benchmark/benchmark.h"
 #include "test_macros.h"
 
 constexpr std::size_t MAX_STRING_LEN = 8 << 14;
 
 // Benchmark when there is no match.
 static void BM_StringFindNoMatch(benchmark::State &state) {
   std::string s1(state.range(0), '-');

libcxx/benchmarks/unordered_set_operations.bench.cpp

 #include <unordered_set>
 #include <vector>
 #include <functional>
 #include <cstdint>
 #include <cstdlib>
 #include <cstring>
 
 #include "benchmark/benchmark.h"
 
-#include "ContainerBenchmarks.hpp"
-#include "GenerateInput.hpp"
+#include "ContainerBenchmarks.h"
+#include "GenerateInput.h"
 #include "test_macros.h"
 
 using namespace ContainerBenchmarks;
 
 constexpr std::size_t TestNumInputs = 1024;
 
 template <class _Size>
 inline TEST_ALWAYS_INLINE

libcxx/benchmarks/vector_operations.bench.cpp

 #include <vector>
 #include <functional>
 #include <cstdint>
 #include <cstdlib>
 #include <cstring>
 
 #include "benchmark/benchmark.h"
 
-#include "ContainerBenchmarks.hpp"
-#include "GenerateInput.hpp"
+#include "ContainerBenchmarks.h"
+#include "GenerateInput.h"
 
 using namespace ContainerBenchmarks;
 
 constexpr std::size_t TestNumInputs = 1024;
 
 BENCHMARK_CAPTURE(BM_ConstructSize,
     vector_byte,
     std::vector<unsigned char>{})->Arg(5140480);