[libcxx-commits] [PATCH] D144362: [libcxx] <experimental/simd> Add ABI tags, class template simd/simd_mask implementations. Add related simd traits and tests.

[Nikolas Klauser via Phabricator via libcxx-commits]

philnik added a comment.

I've applied for patch locally and reworked the instantiation logic a bit. This is my solution:

name=test_utils.h
  //===----------------------------------------------------------------------===//
  //
  // 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 TEST_UTIL_H
  #define TEST_UTIL_H
  
  #include <utility>
  #include <experimental/simd>
  #include "type_algorithms.h"
  
  namespace ex = std::experimental::parallelism_v2;
  
  constexpr std::size_t max_simd_size = 32;
  
  template <template <std::size_t N> class F>
  struct TestAllSimdAbiFunctor {
    template <class T, std::size_t N>
    using sized_abis = types::type_list<ex::simd_abi::fixed_size<N>, ex::simd_abi::deduce_t<T, N>>;
  
    template <class T, std::size_t... Ns>
    void instantiate_with_n(std::index_sequence<Ns...>) {
      (types::for_each(sized_abis<T, Ns + 1>{}, F<Ns + 1>{}), ...);
    }
  
    template <class T>
    void operator()() {
      using abis = types::type_list<ex::simd_abi::scalar, ex::simd_abi::native<T>, ex::simd_abi::compatible<T>>;
      types::for_each(abis{}, F<1>());
  
      instantiate_with_n<T>(std::make_index_sequence<max_simd_size - 1>{});
    }
  };
  
  template <template <std::size_t N> class Func>
  void test_all_simd_abi() {
    using arithmetic_no_bool_types = types::concatenate_t<types::integer_types, types::floating_point_types>;
    types::for_each(arithmetic_no_bool_types(), TestAllSimdAbiFunctor<Func>());
  }
  
  #endif // TEST_UTIL_H

name=is_abi_tag.pass.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
  //
  //===----------------------------------------------------------------------===//
  
  // UNSUPPORTED: c++03, c++11, c++14
  
  // <experimental/simd>
  //
  // [simd.traits]
  // template <class T> struct is_abi_tag;
  // template <class T> inline constexpr bool ex::is_abi_tag_v = ex::is_abi_tag<T>::value;
  
  #include "../test_utils.h"
  #include <experimental/simd>
  
  namespace ex = std::experimental::parallelism_v2;
  
  class EmptyEntry {};
  
  template <std::size_t N>
  struct Test {
    template <class SimdAbi>
    void operator()() {
      static_assert(ex::is_abi_tag<SimdAbi>::value);
  
      static_assert(!ex::is_abi_tag<EmptyEntry>::value);
      static_assert(!ex::is_abi_tag<ex::simd< EmptyEntry, SimdAbi>>::value);
      static_assert(!ex::is_abi_tag<ex::simd_mask< EmptyEntry, SimdAbi>>::value);
  
      static_assert(ex::is_abi_tag_v<SimdAbi>);
  
      static_assert(!ex::is_abi_tag_v<EmptyEntry>);
      static_assert(!ex::is_abi_tag_v<ex::simd< EmptyEntry, SimdAbi>>);
      static_assert(!ex::is_abi_tag_v<ex::simd_mask< EmptyEntry, SimdAbi>>);
    }
  };
  
  int main(int, char**) {
    test_all_simd_abi<Test>();
    return 0;
  }

I think this version is quite a bit easier to follow. WDYT?


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D144362/new/

https://reviews.llvm.org/D144362