17 #ifndef KOKKOS_IMPL_PUBLIC_INCLUDE
18 #include <Kokkos_Macros.hpp>
20 "Including non-public Kokkos header files is not allowed.");
22 #ifndef KOKKOS_KOKKOS_TUNERS_HPP
23 #define KOKKOS_KOKKOS_TUNERS_HPP
25 #include <Kokkos_Macros.hpp>
26 #include <Kokkos_Core_fwd.hpp>
27 #include <Kokkos_ExecPolicy.hpp>
28 #include <KokkosExp_MDRangePolicy.hpp>
29 #include <impl/Kokkos_Profiling_Interface.hpp>
42 namespace Experimental {
45 SetOrRange make_candidate_set(
size_t size, int64_t* data);
46 bool have_tuning_tool();
47 size_t declare_output_type(
const std::string&,
48 Kokkos::Tools::Experimental::VariableInfo);
49 void request_output_values(
size_t,
size_t,
50 Kokkos::Tools::Experimental::VariableValue*);
51 VariableValue make_variable_value(
size_t, int64_t);
52 VariableValue make_variable_value(
size_t,
double);
53 SetOrRange make_candidate_range(
double lower,
double upper,
double step,
54 bool openLower,
bool openUpper);
55 SetOrRange make_candidate_range(int64_t lower, int64_t upper, int64_t step,
56 bool openLower,
bool openUpper);
57 size_t get_new_context_id();
58 void begin_context(
size_t context_id);
59 void end_context(
size_t context_id);
67 template <
typename ValueType,
typename ContainedType>
70 template <
typename ValueType,
typename ContainedType>
72 std::vector<ValueType> root_values;
73 std::vector<ContainedType> sub_values;
74 void add_root_value(
const ValueType& in) { root_values.push_back(in); }
75 void add_sub_container(
const ContainedType& in) { sub_values.push_back(in); }
76 const ValueType& get_root_value(
const size_t index)
const {
77 return root_values[index];
79 const ContainedType& get_sub_value(
const size_t index)
const {
80 return sub_values[index];
84 template <
typename ValueType>
85 struct ValueHierarchyNode<ValueType, void> {
86 std::vector<ValueType> root_values;
87 explicit ValueHierarchyNode(std::vector<ValueType> rv)
88 : root_values(std::move(rv)) {}
89 void add_root_value(
const ValueType& in) { root_values.push_back(in); }
90 const ValueType& get_root_value(
const size_t index)
const {
91 return root_values[index];
100 template <
class NestedMap>
110 template <
class K,
class V>
120 template <
class NestedMap>
128 static return_type build(
const std::vector<T>& in) {
return return_type{in}; }
133 template <
class K,
class V>
134 struct ValueHierarchyConstructor<std::map<K, V>> {
135 using return_type =
typename MapTypeConverter<std::map<K, V>>::type;
136 static return_type build(
const std::map<K, V>& in) {
137 return_type node_to_build;
138 for (
auto& entry : in) {
139 node_to_build.add_root_value(entry.first);
140 node_to_build.add_sub_container(
141 ValueHierarchyConstructor<V>::build(entry.second));
143 return node_to_build;
155 template <
class InspectForDepth>
161 static constexpr
int value = 1;
166 template <
class K,
class V>
171 template <
class T,
int N>
172 struct n_dimensional_sparse_structure;
175 struct n_dimensional_sparse_structure<T, 1> {
176 using type = std::vector<T>;
179 template <
class T,
int N>
180 struct n_dimensional_sparse_structure {
182 std::map<T,
typename n_dimensional_sparse_structure<T, N - 1>::type>;
192 template <
class Container>
196 template <
class RootType,
class Subtype>
199 double fraction_to_traverse) {
200 size_t index = dimension.root_values.size() * fraction_to_traverse;
201 return dimension.get_root_value(index);
212 template <
class HierarchyNode,
class... InterpolationIndices>
215 template <
class ValueType>
218 using return_type = std::tuple<ValueType>;
219 static return_type build(
const node_type& in,
double index) {
226 template <
class ValueType,
class Subtype,
class... Indices>
227 struct GetMultidimensionalPoint<ValueHierarchyNode<ValueType, Subtype>, double,
229 using node_type = ValueHierarchyNode<ValueType, Subtype>;
231 typename GetMultidimensionalPoint<Subtype, Indices...>::return_type;
232 using return_type = decltype(std::tuple_cat(
233 std::declval<std::tuple<ValueType>>(), std::declval<sub_tuple>()));
234 static return_type build(
const node_type& in,
double fraction_to_traverse,
235 Indices... indices) {
236 size_t index = in.sub_values.size() * fraction_to_traverse;
237 auto dimension_value = std::make_tuple(
238 DimensionValueExtractor<node_type>::get(in, fraction_to_traverse));
239 return std::tuple_cat(dimension_value,
240 GetMultidimensionalPoint<Subtype, Indices...>::build(
241 in.get_sub_value(index), indices...));
245 template <
typename PointType,
class ArrayType,
size_t... Is>
246 auto get_point_helper(
const PointType& in,
const ArrayType& indices,
247 std::index_sequence<Is...>) {
248 using helper = GetMultidimensionalPoint<
250 decltype(std::get<Is>(std::declval<ArrayType>()).value.double_value)...>;
251 return helper::build(in, std::get<Is>(indices).value.double_value...);
254 template <
typename Po
intType,
typename ArrayType>
257 template <
typename Po
intType,
size_t ArraySize>
260 std::array<Kokkos::Tools::Experimental::VariableValue, ArraySize>> {
261 using index_set_type =
262 std::array<Kokkos::Tools::Experimental::VariableValue, ArraySize>;
263 static auto build(
const PointType& in,
const index_set_type& indices) {
264 return get_point_helper(in, indices, std::make_index_sequence<ArraySize>{});
268 template <
typename Po
intType,
typename ArrayType>
269 auto get_point(
const PointType& point,
const ArrayType& indices) {
270 return GetPoint<PointType, ArrayType>::build(point, indices);
275 template <
template <
class...>
class Container,
size_t MaxDimensionSize = 100,
276 class... TemplateArguments>
277 class MultidimensionalSparseTuningProblem {
279 using ProblemSpaceInput = Container<TemplateArguments...>;
280 static constexpr
int space_dimensionality =
281 Impl::get_space_dimensionality<ProblemSpaceInput>::value;
282 static constexpr
size_t max_space_dimension_size = MaxDimensionSize;
283 static constexpr
double tuning_min = 0.0;
284 static constexpr
double tuning_max = 0.999;
289 double tuning_step = tuning_max / max_space_dimension_size;
291 using StoredProblemSpace =
292 typename Impl::MapTypeConverter<ProblemSpaceInput>::type;
293 using HierarchyConstructor =
294 typename Impl::ValueHierarchyConstructor<Container<TemplateArguments...>>;
296 using ValueArray = std::array<Kokkos::Tools::Experimental::VariableValue,
297 space_dimensionality>;
298 template <
class Key,
class Value>
299 using extended_map = std::map<Key, Value>;
300 template <
typename Key>
301 using extended_problem =
302 MultidimensionalSparseTuningProblem<extended_map, MaxDimensionSize, Key,
304 template <
typename Key,
typename Value>
305 using ExtendedProblemSpace =
306 typename Impl::MapTypeConverter<extended_map<Key, Value>>::type;
308 template <
typename Key>
309 auto extend(
const std::string& axis_name,
310 const std::vector<Key>& new_tuning_axis)
const
311 -> extended_problem<Key> {
312 ExtendedProblemSpace<Key, ProblemSpaceInput> extended_space;
313 for (
auto& key : new_tuning_axis) {
314 extended_space.add_root_value(key);
315 extended_space.add_sub_container(m_space);
317 std::vector<std::string> extended_names;
318 extended_names.reserve(m_variable_names.size() + 1);
319 extended_names.push_back(axis_name);
320 extended_names.insert(extended_names.end(), m_variable_names.begin(),
321 m_variable_names.end());
322 return extended_problem<Key>(extended_space, extended_names);
326 StoredProblemSpace m_space;
327 std::array<size_t, space_dimensionality> variable_ids;
328 std::vector<std::string> m_variable_names;
332 MultidimensionalSparseTuningProblem() =
default;
334 MultidimensionalSparseTuningProblem(StoredProblemSpace space,
335 const std::vector<std::string>& names)
336 : m_space(std::move(space)), m_variable_names(names) {
337 KOKKOS_ASSERT(names.size() == space_dimensionality);
338 for (
unsigned long x = 0; x < names.size(); ++x) {
340 info.type = Kokkos::Tools::Experimental::ValueType::kokkos_value_double;
341 info.category = Kokkos::Tools::Experimental::StatisticalCategory::
342 kokkos_value_interval;
344 Kokkos::Tools::Experimental::CandidateValueType::kokkos_value_range;
345 info.candidates = Kokkos::Tools::Experimental::make_candidate_range(
346 tuning_min, tuning_max, tuning_step,
true,
true);
347 variable_ids[x] = declare_output_type(names[x], info);
351 MultidimensionalSparseTuningProblem(ProblemSpaceInput space,
352 const std::vector<std::string>& names)
353 : MultidimensionalSparseTuningProblem(HierarchyConstructor::build(space),
356 template <
typename... Coordinates>
357 auto get_point(Coordinates... coordinates) {
358 using ArrayType = std::array<Kokkos::Tools::Experimental::VariableValue,
359 sizeof...(coordinates)>;
360 return Impl::get_point(
361 m_space, ArrayType({Kokkos::Tools::Experimental::make_variable_value(
362 0, static_cast<double>(coordinates))...}));
366 context = Kokkos::Tools::Experimental::get_new_context_id();
368 for (
int x = 0; x < space_dimensionality; ++x) {
369 values[x] = Kokkos::Tools::Experimental::make_variable_value(
370 variable_ids[x], 0.0);
372 begin_context(context);
373 request_output_values(context, space_dimensionality, values.data());
374 return Impl::get_point(m_space, values);
377 auto end() { end_context(context); }
380 template <
typename Tuner>
381 struct ExtendableTunerMixin {
382 template <
typename Key>
383 auto combine(
const std::string& axis_name,
384 const std::vector<Key>& new_axis)
const {
385 const auto& sub_tuner =
static_cast<const Tuner*
>(
this)->get_tuner();
386 return sub_tuner.extend(axis_name, new_axis);
389 template <
typename... Coordinates>
390 auto get_point(Coordinates... coordinates) {
391 const auto& sub_tuner =
static_cast<const Tuner*
>(
this)->get_tuner();
392 return sub_tuner.get_point(coordinates...);
396 ExtendableTunerMixin() =
default;
400 template <
size_t MaxDimensionSize = 100,
template <
class...>
class Container,
401 class... TemplateArguments>
402 auto make_multidimensional_sparse_tuning_problem(
403 const Container<TemplateArguments...>& in, std::vector<std::string> names) {
404 return MultidimensionalSparseTuningProblem<Container, MaxDimensionSize,
405 TemplateArguments...>(in, names);
408 class TeamSizeTuner :
public ExtendableTunerMixin<TeamSizeTuner> {
410 using SpaceDescription = std::map<int64_t, std::vector<int64_t>>;
411 using TunerType = decltype(make_multidimensional_sparse_tuning_problem<20>(
412 std::declval<SpaceDescription>(),
413 std::declval<std::vector<std::string>>()));
417 TeamSizeTuner() =
default;
418 TeamSizeTuner& operator=(
const TeamSizeTuner& other) =
default;
419 TeamSizeTuner(
const TeamSizeTuner& other) =
default;
420 TeamSizeTuner& operator=(TeamSizeTuner&& other) =
default;
421 TeamSizeTuner(TeamSizeTuner&& other) =
default;
422 template <
typename ViableConfigurationCalculator,
typename Functor,
423 typename TagType,
typename... Properties>
424 TeamSizeTuner(
const std::string& name,
426 const Functor& functor,
const TagType& tag,
427 ViableConfigurationCalculator calc) {
429 PolicyType policy(policy_in);
430 auto initial_vector_length = policy.impl_vector_length();
431 if (initial_vector_length < 1) {
432 policy.impl_set_vector_length(1);
459 SpaceDescription space_description;
461 auto max_vector_length = PolicyType::vector_length_max();
462 std::vector<int64_t> allowed_vector_lengths;
464 if (policy.impl_auto_vector_length()) {
465 for (
int vector_length = max_vector_length; vector_length >= 1;
466 vector_length /= 2) {
467 policy.impl_set_vector_length(vector_length);
480 auto max_team_size = calc.get_max_team_size(policy, functor, tag);
481 if ((policy.impl_auto_team_size()) ||
482 (policy.team_size() <= max_team_size)) {
483 allowed_vector_lengths.push_back(vector_length);
487 allowed_vector_lengths.push_back(policy.impl_vector_length());
490 for (
const auto vector_length : allowed_vector_lengths) {
491 std::vector<int64_t> allowed_team_sizes;
492 policy.impl_set_vector_length(vector_length);
493 auto max_team_size = calc.get_max_team_size(policy, functor, tag);
494 if (policy.impl_auto_team_size()) {
496 for (
int team_size = max_team_size; team_size >= 1; team_size /= 2) {
497 allowed_team_sizes.push_back(team_size);
500 allowed_team_sizes.push_back(policy.team_size());
502 space_description[vector_length] = allowed_team_sizes;
504 tuner = make_multidimensional_sparse_tuning_problem<20>(
505 space_description, {std::string(name +
"_vector_length"),
506 std::string(name +
"_team_size")});
507 policy.impl_set_vector_length(initial_vector_length);
510 template <
typename... Properties>
513 if (Kokkos::Tools::Experimental::have_tuning_tool()) {
514 auto configuration = tuner.begin();
515 auto team_size = std::get<1>(configuration);
516 auto vector_length = std::get<0>(configuration);
517 if (vector_length > 0) {
518 policy.impl_set_team_size(team_size);
519 policy.impl_set_vector_length(vector_length);
525 if (Kokkos::Tools::Experimental::have_tuning_tool()) {
530 TunerType get_tuner()
const {
return tuner; }
534 struct tuning_type_for;
537 struct tuning_type_for<double> {
538 static constexpr Kokkos::Tools::Experimental::ValueType value =
539 Kokkos::Tools::Experimental::ValueType::kokkos_value_double;
541 const Kokkos::Tools::Experimental::VariableValue& value_struct) {
542 return value_struct.value.double_value;
546 struct tuning_type_for<int64_t> {
547 static constexpr Kokkos::Tools::Experimental::ValueType value =
548 Kokkos::Tools::Experimental::ValueType::kokkos_value_int64;
550 const Kokkos::Tools::Experimental::VariableValue& value_struct) {
551 return value_struct.value.int_value;
555 template <
class Bound>
556 class SingleDimensionalRangeTuner {
559 using tuning_util = Impl::tuning_type_for<Bound>;
564 SingleDimensionalRangeTuner() =
default;
565 SingleDimensionalRangeTuner(
566 const std::string& name,
567 Kokkos::Tools::Experimental::StatisticalCategory category,
568 Bound default_val, Bound lower, Bound upper, Bound step = (Bound)0) {
569 default_value = default_val;
570 Kokkos::Tools::Experimental::VariableInfo info;
571 info.category = category;
572 info.candidates = make_candidate_range(
573 static_cast<Bound>(lower), static_cast<Bound>(upper),
574 static_cast<Bound>(step),
false,
false);
576 Kokkos::Tools::Experimental::CandidateValueType::kokkos_value_range;
577 info.type = tuning_util::value;
578 id = Kokkos::Tools::Experimental::declare_output_type(name, info);
582 context = Kokkos::Tools::Experimental::get_new_context_id();
583 Kokkos::Tools::Experimental::begin_context(context);
585 Kokkos::Tools::Experimental::make_variable_value(
id, default_value);
586 Kokkos::Tools::Experimental::request_output_values(context, 1,
588 return tuning_util::get(tuned_value);
591 void end() { Kokkos::Tools::Experimental::end_context(context); }
593 template <
typename Functor>
594 void with_tuned_value(Functor& func) {
600 class RangePolicyOccupancyTuner {
602 using TunerType = SingleDimensionalRangeTuner<int64_t>;
606 RangePolicyOccupancyTuner() =
default;
607 template <
typename ViableConfigurationCalculator,
typename Functor,
608 typename TagType,
typename... Properties>
609 RangePolicyOccupancyTuner(
const std::string& name,
611 const Functor&,
const TagType&,
612 ViableConfigurationCalculator)
613 : tuner(TunerType(name,
614 Kokkos::Tools::Experimental::StatisticalCategory::
618 template <
typename... Properties>
621 if (Kokkos::Tools::Experimental::have_tuning_tool()) {
622 auto occupancy = tuner.begin();
623 policy.impl_set_desired_occupancy(
624 Kokkos::Experimental::DesiredOccupancy{
static_cast<int>(occupancy)});
629 if (Kokkos::Tools::Experimental::have_tuning_tool()) {
634 TunerType get_tuner()
const {
return tuner; }
639 template <
typename T>
640 void fill_tile(std::vector<T>& cont,
int tile_size) {
641 for (
int x = 1; x < tile_size; x *= 2) {
645 template <
typename T,
typename Mapped>
646 void fill_tile(std::map<T, Mapped>& cont,
int tile_size) {
647 for (
int x = 1; x < tile_size; x *= 2) {
648 fill_tile(cont[x], tile_size / x);
653 template <
int MDRangeRank>
654 struct MDRangeTuner :
public ExtendableTunerMixin<MDRangeTuner<MDRangeRank>> {
656 static constexpr
int rank = MDRangeRank;
657 static constexpr
int max_slices = 15;
658 using SpaceDescription =
659 typename Impl::n_dimensional_sparse_structure<int, rank>::type;
661 decltype(make_multidimensional_sparse_tuning_problem<max_slices>(
662 std::declval<SpaceDescription>(),
663 std::declval<std::vector<std::string>>()));
667 MDRangeTuner() =
default;
668 template <
typename Functor,
typename TagType,
typename Calculator,
669 typename... Properties>
670 MDRangeTuner(
const std::string& name,
671 const Kokkos::MDRangePolicy<Properties...>& policy,
672 const Functor& functor,
const TagType& tag, Calculator calc) {
673 SpaceDescription desc;
675 calc.get_mdrange_max_tile_size_product(policy, functor, tag);
676 Impl::fill_tile(desc, max_tile_size);
677 std::vector<std::string> feature_names;
678 for (
int x = 0; x < rank; ++x) {
679 feature_names.push_back(name +
"_tile_size_" + std::to_string(x));
681 tuner = make_multidimensional_sparse_tuning_problem<max_slices>(
682 desc, feature_names);
684 template <
typename Policy,
typename Tuple,
size_t... Indices>
685 void set_policy_tile(Policy& policy,
const Tuple& tuple,
686 const std::index_sequence<Indices...>&) {
687 policy.impl_change_tile_size({std::get<Indices>(tuple)...});
689 template <
typename... Properties>
690 auto tune(
const Kokkos::MDRangePolicy<Properties...>& policy_in) {
691 Kokkos::MDRangePolicy<Properties...> policy(policy_in);
692 if (Kokkos::Tools::Experimental::have_tuning_tool()) {
693 auto configuration = tuner.begin();
694 set_policy_tile(policy, configuration, std::make_index_sequence<rank>{});
699 if (Kokkos::Tools::Experimental::have_tuning_tool()) {
704 TunerType get_tuner()
const {
return tuner; }
707 template <
class Choice>
708 struct CategoricalTuner {
709 using choice_list = std::vector<Choice>;
712 size_t tuning_variable_id;
713 CategoricalTuner(std::string name, choice_list m_choices)
714 : choices(m_choices) {
715 std::vector<int64_t> indices;
716 for (
typename decltype(choices)::size_type x = 0; x < choices.size(); ++x) {
717 indices.push_back(x);
720 info.category = StatisticalCategory::kokkos_value_categorical;
721 info.valueQuantity = CandidateValueType::kokkos_value_set;
722 info.type = ValueType::kokkos_value_int64;
723 info.candidates = make_candidate_set(indices.size(), indices.data());
724 tuning_variable_id = declare_output_type(name, info);
726 const Choice& begin() {
727 context = get_new_context_id();
728 begin_context(context);
729 VariableValue value = make_variable_value(tuning_variable_id, int64_t(0));
730 request_output_values(context, 1, &value);
731 return choices[value.value.int_value];
733 void end() { end_context(context); }
736 template <
typename Choice>
737 auto make_categorical_tuner(std::string name, std::vector<Choice> choices)
738 -> CategoricalTuner<Choice> {
739 return CategoricalTuner<Choice>(name, choices);
Execution policy for parallel work over a league of teams of threads.